Logic and The Environment, Part 2: The Clicks and Ports Layer

As we learned in the previous article, Logic and The Environment, Part 1: The Simple Truths, the environment is the place where Logic's various objects live. But now let's add to the bigger picture of what the environment is all about: it's also a place where you can create various objects to exercise control and process MIDI messages which Logic receives from controllers, standalone MIDI applications, and the Mac's own IAC bus. And the place where this is typically accomplished is in the Clicks and Ports layer.

Figure 1: The default objects of the Clicks & Ports layer.

Clicks

Of the five objects which appear by default in the Clicks & Ports layer in any Logic project (Figure 1), the “Clicks” part refers specifically to the MIDI Click, an object which hearkens to Logic's earlier days when it was only a MIDI sequencer; back then it was common to use an external MIDI device to produce a sound for the click, and this object generated the MIDI notes for each beat and subdivision.

However, even if you don't need this capability, don't get all neat-freaky and delete this object from any project because Logic uses it internally to drive the Klopfgeist.

Ports

As shown in Figure 1, the remaining four objects in this layer are connected via cables and forms a diagram showing how MIDI enters Logic. 

Working from left to right, the large rectangular Physical Input object is responsible for gathering all MIDI data coming into your Mac and making it available to Logic. But don't be fooled by the word “Input” in “Physical Input”, because this isn't the point where MIDI data actually enters Logic's MIDI recorder. That comes later.

The little triangles on the right edge of this object are “ports” and each one represents an individual MIDI source coming into your Mac, including virtual and standalone MIDI apps. By default, the MIDI data from all devices is merged inside this object and presented as the Sum output. From there, a single MIDI data stream wends its way towards the input of Logic's MIDI recorder. 

We'll explore the Physical Input in more detail later in this series of articles. For now, let's move on and get that data into Logic!



Moving On…

From the Sum output, MIDI messages pass into a Keyboard object (labeled as “Input Notes”) which will animate in response to incoming notes. You can also click on the keyboard to generate notes, useful as a troubleshooting measure when your controller doesn't seem to be working.

MIDI messages then move on to the next object, a MIDI Monitor (“Input View”). This is superior to the one found in the Transport in that it can display more than one message at a time, as a list.

Figure 2: The MIDI Monitor built into the Transport.

Both the keyboard and monitor objects are “benign” in that they pass MIDI data straight through, unprocessed in any way. 

The ultimate destination for MIDI messages is Logic's Sequencer Input, a non-descript object which represents the actual portal into Logic's MIDI recorder, though it's not its final destination. Read on!

Where the Action Is

Once MIDI hits the Sequencer Input, it is then routed to whatever instrument track(s) are record-enabled. (Of odd interest, you can even record MIDI on audio tracks with the track's record button is disabled.) 

Figure 3: MIDI signal flow from “Sum” to its ultimate destination, the track you've selected. Screenshot shows this layer's objects rearranged slightly, keyboard shortened, and cables colored.

Inserting MIDI Processing

At first glance, the MIDI road map represented in Clicks & Ports might seem like just a handy visual reference for MIDI signal flow in Logic, with a few utility objects thrown in for good measure. However, the cables connecting them can be removed or re-routed to all manner of MIDI processing objects, from simple arpeggiators to highly complex configurations of environment objects that transform MIDI data in musically useful ways.

Adding an Arpeggiator 

The first step is to add an arpeggiator object by accessing the environment's local New menu and selecting the arpeggiator item. It will then appear in this layer as a non-descript little icon not connected to anything. Now it's time to cable it up.

Figure 5.

As you can see in the image below, I've inserted the arpeggiator after the keyboard object and before the monitor. Although neither of those objects are required in any project, this approach makes for some instructive eye candy: block chords you play to feed the arpeggiator will be displayed on the keyboard, while individual notes of the arpeggiated pattern will appear one by one in the monitor as MIDI events.

Figure 6: Inserting an arpeggiator in the Clicks & Ports layer. Of note, with this setup, only the arpeggiated notes will be recorded in Logic, not the chords themselves.

The Role of the Inspector

Note that in the above illustration, the arpeggiator is selected and highlighted; doing this for the arpeggiator and most other environment objects will reveal that objects adjustable parameters in the Inspector. So for the arpeggiator, the Inspector is where you access the traditional controls needed to set the direction, rhythmic value, and so on.

An Example of More Complex MIDI Processing

In late 2011, MacProVideo published one of my Logic projects (available as a free download) featuring my custom-built, environment-based utility for providing specialized control of EastWest Play plugins from a MIDI controller.

In the background of the image below you will see that there are a fair number of environment objects, each of which I individually created, programmed, and cabled up to process MIDI data for this utility. However, in the project it appears as shown in the upper left-hand corner: a control panel in a floating window. The ability to pack environment objects into self-contained units (called macros), hide cabling, and other clean-up options are all features built into the environment itself. 

Figure 7.



Being that this utility is packaged in a macro, it can be inserted in the MIDI signal path in the same way as an arpeggiator object. 

Figure 8.



In the next article, we'll look at how the individual ports are useful, and explore many useful objects which can only be created within the environment.