Who writes their own laser show software?

Hi all,

Back in 2008 I worked on a variety of different pieces of laser display software for Mac OS. One of my favorites was a drawing app, that let you draw with the laser using a graphics tablet:

https://www.youtube.com/watch?v=4JYv1gH_abE

I also wrote an iTunes visualizer plugin to draw abstract pictures that interpreted the audio samples being played back, and worked with some other folks to build a module-based laser show app. It could import Adobe Flash animations, read and write ILDA files, and draw some basic lissajous figures.

Digging back into this stuff this week, I found it wasn't hard to recompile the drivers I had written and the test programs to play .ild files. The driver test app draws a simple rotating torus wireframe animation. It all seemed to work without too much hacking!

I cobbled together some vintage Catweazle scanners, the EasyLase DAC, and a home-brew 405nm laser pointer I had laying about and managed to capture this:

https://www.youtube.com/watch?v=40q5j1xHGFU

Anyway, excited to be writing laser show software again, even if the first little bits aren't terribly impressive. Who else is writing their own show software? What are the major guiding principles you've adopted in designing the user interface?

Hey Joey,

Looks like fun. Might it also work with trackpads? I'm also in San Francisco, and I'd love to see your stuff live...

Ron

There are a lot of laser show software developers on this forum!

Have you tried LaserBoy? It compiles and runs in Mac OSX.

It's free and open source.

I started on it at the end of 2003.

The user interface is all keyboard, because of the origin of the code as a whole. I started writing it for Linux. It used to take two computers to work. One was a Linux machine that provided a high resolution graphics display. The other was another machine that shelled into the first to control the application. I know that sounds weird, but I am very used to the idea of working with Linux servers via a shell.

Then someone introduced me to libSDL 1.2 so I could write one single code set that would compile and run on just about every modern OS. I stuck with the keyboard control because i had already developed so much of the code to work that way. And, once you get used to it, you will find that it is very precision oriented.

James.

Ron, I think trackpads aren't as well suited to this application because they're relative, as opposed to absolute positioning devices, like graphics tablets. Additionally this worked well with tablets because it is possible to distinguish between hovering above the surface and touching the stylus to the tablet.

These days it might be possible to replace the tablet with an iPad + pencil.

I'll let you know when I have some good stuff to demo.

—Joey

James,

Glad to hear from you! I guess I had discounted LaserBoy somewhat simply because the website looked as if it had been maintained, but I guess my impressions were quite wrong! Sorry about that. I'll have to get it compiling and take a look.

I guess I should start just surveying every app I can find and building up a bit of a taxonomy of the different sorts of things out there. I see a lot of different apps and it seems that there are a variety of different philosophies on what an app to drive a laser project should look like.

Most software appears to assume control of a given laser projector—and this has held true for all of my experiments as well.

Are there any examples of a more plugin-based architecture, where a central app would connect to a projector, handle issues like color correction, display geometry, synchronization, and other modules would be responsible for generating source frames? This way a show could easily incorporate elements from different creation apps—not just exported .ild files, but live elements—but each wouldn't have to reimplement all of the "utility" kinds of functionality that each app might need. This would also deal with hardware arbitration—so different sources weren't trying to connect to the hardware at the same time.

Seems like it would be possible to build a prototype my making a coordinator app show up as several "virtual DACs", that different apps could connect to like a regular hardware projector, then the coordinator app could sequence among those different input sources when writing to the real hardware projector, and apply screen geometry correction, color correction, etc

Eventually a better plugin API could exist to facilitate bi-directional communication between the host app and the content generators—but that would necessarily require adoption of any client app, whereas this prototype would not need such a thing.

—Joey

I am not a Mac user, so I have never compiles LB myself for Mac OSX.

I will tell you that you need the boost C++ libs and libSDL 1.2.

Also, when you exit the app, there is an un-handled exception when SDL cleans up. It looks like it crashes the app at the exit, but it doesn't effect any of the operation of the app. This only happens on a Mac.

LB does not connect to any DAC what so ever. It is purely file IO.

One of the things it does is make wave files of time optimized laser show content for modified sound card DACs.

It reads and writes all formats of ILDA. Plus it reads DXF files.

It lets you create all kinds of art either by directly drawing it or using parameters for various math figures (like Spirograph).

You can also render text in a variety of fonts.

There are special effects that you can apply to single frames or frame sets to make animations.

Plus lot of other cool stuff.

The idea was to create an experience that is exactly the same on all operating systems.

Quote:

---

Originally Posted by joeyhagedorn

Most software appears to assume control of a given laser projector—and this has held true for all of my experiments as well.

Are there any examples of a more plugin-based architecture, where a central app would connect to a projector, handle issues like color correction, display geometry, synchronization, and other modules would be responsible for generating source frames? This way a show could easily incorporate elements from different creation apps—not just exported .ild files, but live elements—but each wouldn't have to reimplement all of the "utility" kinds of functionality that each app might need. This would also deal with hardware arbitration—so different sources weren't trying to connect to the hardware at the same time.

---

LSX can now do that in a way. The most recent version has a feature where you can send a laser frame to it over OSC in real time. So you can write your own laser program that generates laser art and have it send frames to LSX. Since OSC is a network protocol the program doesn't even need to run on the same computer as LSX. You could have a computer at the back of the stage running LSX connected to a bunch of DACs and send frames to it over ethernet from anywhere you want. This is really convenient as LSX has support for a multitude of DACs with optimisation, BAMs and the whole package so you don't have to deal with that as a software dev.

I intend to write a live show program that is... less cumbersome... than LSX. It's gonna have the ability to play multiple cues at the same time. And colour saturation =)


LSX is developed by PL member drlava, to answer your original question. One for the list.



Another is my own program, IldaViewer:

Attachment 51255

Check out the Oscillabstract tab. I got it working with LSX in real time, too!

https://www.youtube.com/watch?v=MZ_Cgq640jQ

Quote:

---

Originally Posted by colouredmirrorball

Check out the Oscillabstract tab. I got it working with LSX in real time, too!

---

Oscillabstract? What is this witch craft you speak of?

-Sal

It started out as an idea to connect oscillators together to create abstracts. Then I wanted some options to dynamically rotate, translate, scale and colour the frame. Then suddenly I found out I created a node based ilda file editor/creator.

Attachment 51256


Then I made it output to LSX.

Attachment 51257

Next step is to add live inputs but that's not going to be for soon. I want to rewrite it first and I simply don't have the time for that.

Quote:

---

Originally Posted by discothefunkyhippo

Oscillabstract? What is this witch craft you speak of?

-Sal

---

Yeah! What?!

That's awesome! *retardo

colouredmirrorball,

Wow, yeah, I had no idea LSX had that capability; really happy to hear that model has been pursued. I haven't dug into what the LSX/OSC API is yet, but I will check it out. I believe orienting around a model like this can really reduce the barrier to entry to writing interesting graphics code and visualizations without all of the utility stuff.

Oscillabstract is exactly the kind of stuff I was wondering about. So excited to see this kind of software creativity—a node based editor is a really neat idea.

I checked out your youtube channel and there are some really cool Leap Motion demos as well; drawing and 3d control of an object. Love this stuff.

—Joey

Node based editing has been done before with DigiSynth. Sadly it's a bit out of reach for the hobbyist budget.



Leap Motion is cool but the real stuff requires a lot of work. There are only some basic gesture recognitions available. Playing around with finger coordinates can do simple stuff but if you use it in that way it's just a gimmick. It would be cool to have a feature where you can eg. swipe in midair to go to the next cue, make a gesture like an orchestra conductor to slow the effect speed down, change colour with a snap of your fingers etc. but that's not simple in any way. It's not reliable in that way, if you use it for these kind of triggers it would miss half of them and misinterpret the other half.

There are quite a few of us here on PL that have written our own laser software. The development of my app, Maxwell, is pretty well documented in this thread here:

http://www.photonlexicon.com/forums/...th-(analogish)

We've even had some decent f̶i̶g̶h̶t̶s̶ ̶ discussions about Mac vs PC for laser software... of course Mac always wins :)

Here is a jsfiddle page which can take a point array from an ILDA file and display an ILDA frame - all in html/javascript

http://jsfiddle.net/wj7tsqLe/10/

And here is a small little custom app which allows you to drag-n-drop ILDA files to display the frames, and export any of the frames as a set of points:

https://www.youtube.com/watch?v=kD3crtcwG1M

Quote:

---

Originally Posted by colouredmirrorball

It started out as an idea to connect oscillators together to create abstracts. Then I wanted some options to dynamically rotate, translate, scale and colour the frame. Then suddenly I found out I created a node based ilda file editor/creator.

Then I made it output to LSX.

Next step is to add live inputs but that's not going to be for soon. I want to rewrite it first and I simply don't have the time for that.

---

As The Count has previously stated, this is indeed awesome!

-Sal

Dear Sir/Maam

Would you please give me more detail of your work? may i have your email for further question? i want to develop a game framework, i am really interested to talk with you,

Regards,
Sami

Quote:

---

Originally Posted by joeyhagedorn

Hi all,

Back in 2008 I worked on a variety of different pieces of laser display software for Mac OS. One of my favorites was a drawing app, that let you draw with the laser using a graphics tablet:

https://www.youtube.com/watch?v=4JYv1gH_abE

I also wrote an iTunes visualizer plugin to draw abstract pictures that interpreted the audio samples being played back, and worked with some other folks to build a module-based laser show app. It could import Adobe Flash animations, read and write ILDA files, and draw some basic lissajous figures.

Digging back into this stuff this week, I found it wasn't hard to recompile the drivers I had written and the test programs to play .ild files. The driver test app draws a simple rotating torus wireframe animation. It all seemed to work without too much hacking!

I cobbled together some vintage Catweazle scanners, the EasyLase DAC, and a home-brew 405nm laser pointer I had laying about and managed to capture this:

https://www.youtube.com/watch?v=40q5j1xHGFU

Anyway, excited to be writing laser show software again, even if the first little bits aren't terribly impressive. Who else is writing their own show software? What are the major guiding principles you've adopted in designing the user interface?

---