Category Archives: Uncategorized

TouchDesigner | Email | Project Perspective

I do my best to talk with lots of folks using Touch, and sometimes I get questions about my approach and perspective on projects from students approaching their thesis project.  The exchange below comes from an email series between me and @desn.joshmichael.

 


What ways do you find interacting with audio interesting?

Audio isn’t really my wheelhouse, so this one is a little hard for me. What I can say is that I always love working with folks who love sound, and are compelled by its nature. I like working with audio engineers and artists because they see the world differently than I do, which always makes for interesting conversations and typically pushes boundaries. One of my favorite collaborations looked at how we could use video to mix sound through an array of 40+ overhead channels. Video was our gain control, so the shape of the video drove the mix of the audio. Neither the sound artist or myself could have gotten there without the other.

All that aside, I think the bigger question here is what makes interacting with audio interesting to you? At the end of the day that’s what really matters, not what I say or anyone else. What drives you to work with audio, and what do you find most compelling about it?

What role do you think audio plays in an immersive experience?

It can play lots of roles – it can be place making, or provide subtext, or context, or motivation. It can drive action, compel participants or audience members to linger and reflect, or motivate action and decision. Like any medium it can be used to great effect for many purposes. Again, it comes back to questions about what you want it to do. If it can be anything, what do you want to shape it into?

It’s easy to think of an artistic form as having a particular fixed role – it’s much more challenging to consider that the form is role-less; that its purpose is shaped by the designer / artist / engineer – conjured and manipulated in ways both unexpected and familiar. A question actors always confront is to consider the opposite intention of their character. The words in a script seem to indicate that Mary loves Paul… but what if she hates him? What if she despises Paul, but still says loving words to him? What does that do to Paul? What does the audience see and feel? Do they even have to know that Mary hates him, or is it enough that the actor knows?

Ask yourself what role you think audio should play – then ask yourself what would happen if you tried to make it do the opposite thing.

For the general public, what type of audio-visual experiences have you seen success with?

I’ve seen all manner of things succeed that should have failed, and things that should have failed succeed. Worrying about what will or won’t work is to evaluate the art while making it – don’t do that. Make work that’s compelling and interesting to you. After the dust settles you can take time to evaluate what could have been differently, what was missing, what you needed more or less of. I’ve seen so many artists fall into the trap of being critic and designer at the same time – consider what’s compelling to you, reduce it to its most essential ideas and work from there.

What types of practical applications do you think an immersive audio-visual experience could have?

Questions about practicality are always frustrating to me – they aim to reduce an expressive medium into something that can be a commodity, something to be marketed and sold. There are lots of ways to chase this question, but I almost always end up feeling miserable thinking about them. A brilliant actor I once knew used to say that an actor’s goal should be to do nothing more than to change the way people in the audience breathed. If you can make someone hold their breath in anticipation, or sigh in relief, or snort uncontrollably – you’ve done your job as an actor. As a video artist I try to think the same way. If I can make something that inspires someone to stop and linger – to pull out their phone and Instagram something, that’s success.

That might not seem practical, but for a marketing campaign maybe it is – we live in a strange time, a time when it’s often enough if you’re able to just disrupt the regularity of peoples lives, to interrupt and disrupt the regularly scheduled monotony and inspire a moment of reflection and observation.

How do you feel about audio-visual generation as the sole experience? Should there be more to it?

Do you think all immersive experiences need a message or greater purpose to be interesting? Why / Why not?

One of the most important lessons I learned in my grad program was to question if an installation / experience needed to be diegetic (explained) or not. Some experiences (educational, informational, etc) lend themselves to diegesis, others don’t. For the most part, I prefer art that isn’t. I like to trust that the viewer / audience is the epicenter of meaning making, and to trust that a human will strive to construct a narrative and meaning even if I don’t supply one.

Humans are largely biological pattern recognition machines – we strive to make programs to recognize patterns, and we thrive in situations where pattern recognition is important; we even often find patterns in data that doesn’t lend itself to actual patterns (see confirmation bias and any number of fallacies formal and informal). An observer will make meaning in the meaningless. That may be discouraging, but it’s also tremendously freeing. Make the art that’s interesting to you, and know that your audience will weave their own story around what they’re seeing… regardless of whether or not you help them get there.

Any other advice for a beginner in designing an entire experience for the first time?

Learn and use a version tracking system.

I remember my grandmother telling me that my eyes were bigger than my stomach when I was a young. That’s a colloquial way of saying that you’ve bitten off more than you can chew – that you’ve taken more food than you can eat… though I don’t know that I really understood that until I was older. One of the hard lessons I’ve learned is that it’s easy to love all of your ideas, to say “yes and” to all of the permutations of an idea. When you’re brainstorming and dreaming that’s very important – but it’s also tremendously important to revisit those ideas and reduce them to their most basic ingredients. Time and again I see artists fall into the trap of making something that tries to do everything – and they end up with something that’s generally mediocre and flat.

If you can, resist that urge.

Chase an idea to its most basic representation; cut away all the fluff and bullshit and find the thing that’s really interesting and focus on that. Cultivate your laser focus and aim to execute a small idea with precision and excellence… then encourage that idea to grow. Iterate before you abandon an idea, and iterate even when you don’t like some of the things you’re doing. Find the patience to keep exploring an idea even when you feel like it’s exhausted and boring – push though that stuck feeling, and stay attentive.

Learn and use a version tracking system.

With enough time you can make anything with anything – that’s great, but don’t fall into the trap of believing that you have to reinvent the wheel.

Be attentive to details. I can’t tell you how many times I’ve gotten lost in code trying to solve a problem that was really a bad cable, or trash connector. Cultivate a debugging and troubleshooting routine that will help you identify where a problem lies.

Think through your decisions before you commit to them – make good system diagrams, map out your work flow, make a careful and measured plan before you start coding yourself into a corner.

Unit test. Explore an idea or code based solution in isolation before you wrap it into your project – there’s no worse feeling than having to work around your own kludges.

Learn and use a version tracking system.

Play the long game – when I started my grad program I knew that everything I blogged about was eventually going to be a part of a larger portfolio piece. So before I even knew what my thesis was going to be, I knew that I had to keep writing to feed the larger project. Find ways to integrate elements of other assignments / shows / installations / explorations into your thesis. If you can, find a way to tie everything back to your larger thesis project – think about all the component pieces you’ll need for your thesis and figure out how to work on those pieces in other assignments or classes. I can’t tell you how many people I’ve seen spread themselves across all manner of disparate projects only to realize too late that none of what they’ve done is applicable to the work they really want to do.

Comment your code. You’ll thank yourself a thousand times over for keeping notes, even if they’re bad ones. Any breadcrumb is better than nothing when you’re trying to figure out what your 3 AM over caffeinated and tipsy self was trying to make work.

Don’t play it safe. If you have to choose between a bold and dangerous move and tepid one, choose the dangerous option. Experiences that result in strong feelings from participants – even if they’re negative feelings – are more useful as a critique than tepid ones. Strong responses are easier to read, interpret, and course correct from than bland reactions.

Finally – remember that failure is an option when you’re in school. When a client has payed you a ton of money for a project you’ve got lots of pressure to successfully execute an idea, which means that you’ll likely have to compromise on some artistic element. As a student it’s okay if something goes completely wrong, or is awful in every way. Your journey and process is as valuable and important as what you make – that’s hard to find out in art for trade world; so be bold and own your failures – they’re as valuable as your successes and will probably teach you much more in the long run.

No, but really – Learn and use a version tracking system.

scriptDAT | Tips and Tricks | TouchDesigner

If you spend lots of time setting up parameters in your UI elements and want a faster way to use a set of presets to populate some parameters, then the Script DAT might be just what you’re looking for.

Let’s look at a fast simple example that might have you re-thinking how to quickly set up pars in a project. Keep in mind that this won’t work in every situation, but it might work for an awful lot of them and in ways that you might not have expected.

To get started let us imagine that we have a simple set-up where we have a UI element and a display element. We want a fast way to quickly update their parameters. For the sake of this example let’s imagine that we do not need any fancy scaling or changes on the fly. This is going to be used on a set of displays where we know exactly how they’re going to display. We might think about using storage to set and pull parameters, but you might be hesitant to use too much python for those bits and bobs. Okay, so exports it is… they’re a little more cumbersome to set up, but they are much faster – fine.

Sigh.

I guess we need to start setting up an export table, or a constant CHOP and dragging and dropping all over creation. Before you do that though, take a closer look that is the majesty of the Script DAT:

The Script DAT runs a script each time the DAT cooks and can build/modify the output table based in the optional input tables. The Script DAT is created with a docked (attached) DAT that contains three Python methods: cook, onPulse, and setupParameters. The cook method is run each time the Script DAT cooks. The setupParameters method is run whenever the Setup Parameter button on the Script page is pressed. The onPulse method is run whenever a custom pulse parameter is pushed.

Maybe we can use the Script DAT to make an export table for us with just a little bit of python.

We can start by putting a few things into storage. Let’s create a new dictionary but follow some simple rules:

  • The keys in this dictionary are going to be operator names or paths
  • Each operator is itself a key for another dictionary
  • The keys of that dictionary must be proper parameter names
  • The values associated with these keys need to be legal entries for parameters

Okay, with these rules in mind let’s see what we can do. Open up a new project, in project1 let’s create two new containers:

  • container_ui
  • continer_led_display

Add a new text DAT and create a simple dictionary to put into storage, and let’s follow the rules we described above:

# it's important here to know that 
# pars need to match their correct
# parameter name in order for this to
# work correctly.

# in that same vein, the relative paths
# are based on the location of the script
# op that's being used

# finally, for this to work correctly, you'll
# need to re-run this dat in order to place
# new values into storage

attr = {
    "container_ui" :{ 
        "w" : 500,
        "h" : 1080,
        "alignorder" : 0
    },
    "container_led_display": {
        "w" : 400,
        "h" : 300,
        "alignorder" : 1
    },
    "..":{
        "align" : 1,
        "justifyv" : 1
    }
}

parent().store( 'set_up_attr', attr )

Alright, so far so good. Now let’s add a Script DAT.

We’re going to use our Script DAT to look at our stored vals and create an export table on the fly for whatever is in the storage dictionary “attr” – easy.

Let’s edit our Script DAT to have the following contents:

# me - this DAT
# scriptOp - the OP which is cooking
#
# press 'Setup Parameters' in the OP to call this function to re-create the parameters.

# define where pars is coming from
pars = parent().fetch( 'set_up_attr' )

def setupParameters(scriptOp):
    return

# called whenever custom pulse parameter is pushed
def onPulse(par):
    return

def cook(scriptOp):
    scriptOp.clear()

    # insert header row
    scriptOp.insertRow( [ 'path', 'parameter', 'value', 'enable' ] )

    # loop through dictionary for pars
    for key, value in pars.items():
        for item_key, item_value in value.items():
            scriptOp.appendRow( [ key, item_key, item_value, 1 ] )

    # set up parent pars for heigh and width
    parent_height = max( [ pars[ 'container_ui' ][ 'h' ], pars[ 'container_led_display' ][ 'h' ] ] )
    parent_width = sum( [ pars[ 'container_ui' ][ 'w' ], pars[ 'container_led_display' ][ 'w' ] ] )
    scriptOp.appendRow( [ '..', 'w', parent_width, 1 ] )
    scriptOp.appendRow( [ '..', 'h', parent_height, 1 ] )

return

Finally, let’s turn on the green export flag at the bottom of our Script DAT:

script_dat.PNG

And just like that we’ve set-up an auto-export system. Now every time we update our dictionary run our script to put the contents into storage we’ll automatically push those changes to an export table.

Looking for an example to pull apart – head over to github and download a simple example to look over.

Cellular Noise

A post shared by Matthew Ragan (@raganmd) on

 

A post shared by Matthew Ragan (@raganmd) on

 

Practice your vertex shaders

A post shared by Matthew Ragan (@raganmd) on

 

A post shared by Matthew Ragan (@raganmd) on

 

A post shared by Matthew Ragan (@raganmd) on

 

A post shared by Matthew Ragan (@raganmd) on

 

A post shared by Matthew Ragan (@raganmd) on