EddieOffermann dot com

I've been doing a bit of coding specifically to make it easy for Big Blue Ceiling to be deployed into a facility that already has an established file structure.

By itself, this is a natural approach - and not that complicated. Because everyone with *any* sort of organization will have arranged their projects by job and by shots on that job, even though the exact heirarchy may be different it's easy to predict where the *gaps* in that heirarchy may exist and allow those to be configurable by the end user.

For instance, Company A, using predominantly linux machines may have a path to their publishing directory like this:

/FACILITY/cg/PROJECT/SUBPROJECT/shots/aa010/pub/

Company B may use a path on their Macs more like this:

/Volumes/Share/projects/PROJECT_SUBPROJECT/shot/aa010/publish/

It's not exactly brain surgery to identify that in the first case, the meaningful root directory is "/FACILITY/cg/" and in the second it's "/Volumes/Share/projects/" - then there's identifying the delimiter between "show" and "subshow" or "campaign" and "spot" or whatever your nomenclature is for project & subproject info. Maybe they're grouped as folder/subfolder, maybe they're companion folders.  Maybe there's no concept of "subshow" at the facility and we can treat both the delimiter and the subshow as empty.

But this got me to thinking: what I'm doing is creating a visual effects pipeline that is essentially filestructure agnostic.

A large part of a formalized visual effects pipeline is putting the filesystem behind an abstraction layer from the user.  Camera data moves along from artist to artist with each artist knowing nothing more than what shot they're working on. Someone will have specified, early on, what assets will be needed in the shot: ideally, when the shot comes to the animator, they pop open Maya and click a button that makes it populate their scene with the camera, models, set geo, rigged characters, etc.

They don't need (nor do they really want) to know that the model is called "candyBarDancer_v09.mb" and it's stored in "/Volumes/Share/projects/CANDY_DANCE/shot/cd090/publish/rig/".  They don't need to know it, they don't want to know it, and I believe they shouldn't even be *aware* of it because that information is nothing but a distraction from what they're trying to do.

When they're done, they can save a copy of their scene wherever they like for their own edification.  But the data needs to travel to the next artist - and they shouldn't have to tell the next artist where they saved it: again, they shouldn't even *know* this information because the data that gets written out isn't directly usable by them anyway. It's the formal vfx pipeline toolset that manages the handoff and makes sense of the data. Not the artist.

When the pipeline is properly structured, it's perfectly reasonable for multiple artists to work on the same shot at the same time: all the while getting regular updates of animation being done by other artists, receiving model changes relevant to their scene, etc. - all without having to be conscious of where this data is coming from and without having to do anything more than click an "update scene" button.

But here's the big deal!

By building the pipeline software itself around a filesystem agnostic abstraction layer, it allows us to link up established remote facilities. Company A in Los Angeles and Company B in England could be working on the same shots on the same shows, can still actively collaborating using something like Big Blue Ceiling coordinating between their facilities. The fact that their filesystems may have different naming schemes and different heirarchies, even calling the job and shots by different names, isn't going to affect their ability to actively communicate with one another.

Think about it: you have a small studio in Santa Monica and you're working on a medium budget feature with only a handful of effects shots. One of the sequences, however, needs a large set extension and a matte-painted cityscape in the background. You task your team to get to work on the foreground elements of the set extension and contact a small studio in Austin, passing along the requirements for the elements and having them install the toolset for using the shared effects pipeline. They can easily fit it into their filesystem and in no time, they're up and running.

As your artists work on the foreground elements, they register with the system to receive notifications as elements are updated. They click a shelf button to update their scene and as they build the foreground, they see the background elements and matte painting slowly taking shape: right there in their scene.

There's no messy FTP'ing of files back and forth, and no complicated backend server synchronization to set up. They don't even use the same file heirarchy: but that doesn't matter because structure and naming conventions are handled by the pipeline software, not the artists, so there's no confusion.

This is the promise of truly good pipeline design.

And Big Blue Ceiling is going to make that a reality.

As long as we're here, let's take a look at a commercial that I look on fondly, because a lot of what's described above I already wrote once when at Asylum and was used to create this spot.

I've been working on the spec for Big Blue Ceiling and thought I'd share at least an introduction to what the project will deliver. I've changed jobs recently (still in the vfx software/pipeline/td world) and that, among other things, has interrupted the project a bit but I'm ramping back up on it now.

Below are some thoughts on what a pipeline is and how I envision Big Blue Ceiling.  There is so much more to say, but much of it will have to remain unsaid until the project is closer to launch. I believe it will change the world and transform how and where we do business.

What is a visual effects pipeline?

A vfx pipeline is a collection of tools, processes and standards that permit and ensure the following:

-    Efficiency of communication of assets

o      Models

o      Animation

o      Camera data

o      Textures

o      Lighting information

o      Simulation data

o      and anything else necessary to assemble a given scene

-    Standardization

o      Filenames

o      Storage hierarchy

o      Version management

o      Tools

-    Show, Sequence and Shot Management

o      Structure

o      Dependencies

o      Assignment and Evaluation

A formal visual effects pipeline in a traditional effects house serves to automate the transfer of data by abstracting it. Separating camera characteristics, lens and movement data, from its strict representation inside the software package. Treating models, rigs and animation and separate elements that can be updated individually: for instance, animation may begin before a character design is finalized and the models updated on the fly, per shot or across the entire show without losing the animation data or requiring a complicated manual process to transfer that animation onto the updated model or rig.

On the compositing side, it may involve providing an additional set of facility-wide tools that standardize certain effects or provide a particular look.  Tools for grading and color management may be developed for the facility or the particular show and distributed between the artists to ensure that different compositors are able to deliver visually similar shots with minimal headaches.

For the entire facility, a formalized pipeline will ensure that assets and media are located with predictable names and stored in standard locations, along with maintaining project history and asset version information. If the last animation, the last comp, or last week's version of a model are preferable, it's easy to return to that version - often this can be made to happen at the level of producers without having to send the shots back to an artist to make the necessary adjustments.

What then is a cloud-based visual effects pipeline?

With the emergence of cloud computing, many common applications are moving onto a new platform: instead of being contained by a conventional desktop operating system or local server infrastructure, they are being moved onto platform-agnostic, internet-based hosted application clusters. Popular examples that many users are familiar with are such services as Google Docs, the office suite provided online as part of Google’s service offerings, or Photoshop.com, Adobe Corporation’s online photo editing and gallery hosting service. Medical information, insurance software, procurement & fulfillment systems, and tons and tons of software development have all left localized corporate infrastructures and moved onto the Cloud.

For visual effects and other CG projects such as animated features or game development, the process is a little more complicated. It’s still impractical to move software like Maya, 3D Studio Max or Houdini off of workstations and onto a web-based platform. Pipeline management has been complicated by the sizes of files that are often involved, but more recent developments in existing internet infrastructure have brought fast broadband into the range of slower local area networks, opening up the option of intelligent management and delivery of data by software such as Big Blue Ceiling. While many facilities are hesitant even to share projects with other facilities because of the combination of file transfer times and manpower overhead involved in delivering hard drives or preparing data before and after manual transfers over FTP. A Software-as-a-service or cloud-based system such as Big Blue Ceiling handles the typical database and project management aspects of a traditional in-house pipeline, as well as managing data for effortless transfer between facilities or between facility and remote artist.

What is a “Software as a Service” solution?

Software as a service (SaaS, typically pronounced 'sass') is a model of software deployment whereby a provider licenses an application to customers for use as a service on demand. SaaS software vendors may host the application on their own web servers or upload the application to the consumer device, disabling it after use or after the on-demand contract expires. The on-demand function may be handled internally to share licenses within a firm or by a third-party application service provider (ASP) sharing licenses between firms.

What is Big Blue Ceiling?

Big Blue Ceiling is a special subcategory of SaaS solutions referred to as SaSS (Software as a Secure Service). Software as a secure service (SaSS) is a derivative of software as a service. SaSS denotes a class of software as a service which emphasises security, not only in the link to and from the service, and the storage of any content by the software providing the service, but also in the security of the user in terms of the ability to make consistent backups and restores of any data stored in the service, in a non-proprietary format. In other words, security in transmission, storage and control over the user's own data.

In the context of a Cloud-Based Visual Effects Pipeline Software-as-a-Secure-Service, Big Blue Ceiling is a method of providing the sort of sophisticated visual effects pipeline normally restricted to larger, established visual effects houses, not only enabling it to be used by smaller studios but at the same time decentralizing it in such a way that it is as efficient for a group of broadly spread artists working in different locations as it is for a tightly integrated team of artists in a centralized studio.

Why would I be interested in a cloud-based, software-as-a-service solution for my visual effects pipeline?

The traditional rationale for outsourcing of any IT system involves applying economies of scale to the operation of applications, such that a service provider can offer better, cheaper, more reliable applications than companies can themselves. Several important changes to the way people work have made the rapid acceptance of cloud-based solutions possible and these changes are even more notable when we consider the visual effects community.

I.               High performance computers are widespread: Most cg & visual effects artists not only have a home computer but have one capable of performing functions far in excess of the basic needs of checking email and consuming online media.

II.             Processing power is a commodity: In the vanishing past, innovations in hardware were considered strategic advantages. From optical printers in the analog days to the first digital to film transfer processes of the TRON era, for many years hardware was king. More recently, proprietary applications and software tools were viewed as strategic. Today, people know it’s the business processes and the data itself: customer records, artist techniques, pricing information, and good effects design. Computing and application licenses are cost centers, and as such, they’re suitable for cost reduction and outsourcing.

III.           “Insourcing” pipeline systems requires expensive overhead including salaries, health care, hardware, software and OS management, liability and physical building space: not to mention unproductively reinventing the wheel!

IV.          Applications have tended to standardize: with a few notable exceptions, most people spend most of their time using standardized applications. A handful of standard 3d software packages dominate the market and they’re capable of exchanging data in a small set of standardized exchange formats. This means that a comprehensive solution for managing digital assets will work for a wide range of projects and facilities. Purpose-built, facility-specific pipelines should be regarded as dinosaurs.

V.            Web systems are incredibly reliable: Despite sporadic outages and slow-downs in the past, most people today are more than willing to use the Internet as a critical component of their business. As of early 2010, the visual effects community is behind many other information-related industries in moving out of centralized work clusters and into the cloud, largely because there has been no sound approach to managing the complex assets and often considerable data transfers involved.

VI.          Security is sufficiently well trusted and transparent: Secure communication no longer requires a complicated VPN setup or, worse, leased lines. Confidential client data can be handled even remotely with little risk.

VII.        Bandwidth of wide-area networks has grown drastically following Moore's Law (more than 100% increase each 24 months) and is reaching the bandwidth of slow local networks. Added to network quality of service improvement this has driven people and companies to trustfully access remote locations and applications with low latencies and acceptable speeds. Additional layers of asset data management by Big Blue Ceiling additionally boosts apparent speed of access while boosting quality of the artist experience.

VIII.      Cloud-based “Software as a Service” solutions have the effect of democratizing software, allowing small and medium businesses to have access to functionality formerly the domain of large enterprises. Big Blue Ceiling provides pipeline services at a level that small and even midsize companies could never afford to develop on their own, with a continually evolving set of tools and features unmatched even by in-house proprietary systems.

Who can benefit from Big Blue Ceiling?

Simply put, nearly everyone!

An entirely centralized studio can use Big Blue Ceiling and continue working as a centralized facility, leaving ongoing pipeline development to the Big Blue development team, regularly rolling out new features, support for additional packages and powerful artist tools, while letting the studio focus on creativity and project execution. And that centralized studio can rest easy knowing that if they need to expand, open up other locations, or cooperate on projects with artists and other facilities around the world, a set of tools are already in place for them to make sharing data completely effortless!

Smaller, newer facilities, perhaps formed just to accomplish a single project such as an animated short or independent animated feature can benefit enormously from a convenient slip-on pipeline like Big Blue Ceiling. It’s low entry cost provides world-class effects facility capabilities at a budget that nearly any production can absorb. Your cost savings just in artist hours transferring files and maintaining versioning, will easily exceed the entry cost of the service for small projects.

Loose collectives of artists will benefit from the Big Blue toolset as well, whether they’re seasoned industry professionals working purely for the love of the art or students collaborating on a project, access to the class of data management tools provided by Big Blue Ceiling should easily catapult any group’s efficiency.

Mid-size and larger facilities will find the toolset handy not only for their in-house work but for the ability to quickly and easily add artists in remote locations, or to easily permit secure access to their assets and production database by producers and vfx supervisors who may be offsite.

Additionally, tools that monitor times to complete tasks are able to chart them against production cost estimates, easily indicating unexpected burdensome cost centers, suggesting areas that estimates might be adjusted or manpower requirements reconsidered to adjust schedules. These are benefits that very, very few pipelines can provide, even in large established facilities.

As I'd promised earlier, I'll be doing a quick run-through of how matrix multiplication can be used to rotate, scale and translate coordinates through 3d space. First, though, I'm going to write a little bit about a tool I've been working on and just launched. Sorry: the actual code for it is proprietary, so I can't share it, but a brief discussion of the tool and what it needed to be able to do will help illustrate why matrix transformation is so important, even when you're not creating a 3d package from scratch or developing a game engine.

I needed a way to quickly create a usable "right eye" camera to correspond to a "left eye" camera. I needed to be able to specify interocular distance (the distance between the left and right eye), as well as the convergence distance (where the eyes were focusing). Our eyes naturally "converge" on objects that are in front of us - this is part of how we judge relative depth as this convergence affects the apparent relationship if the dual images our eyes perceive of *other* objects that are not at the point of convergence. But that's a subject for another entry.

Anyway, the tool needed to be able to take a tracked "left eye" camera and apply that tracking data to generate the "right eye" camera using convergence and interocular information that was either derived from a track, noted on set, or dynamically assigned in Maya. I wanted a right eye camera that could be created instantly and that would automatically follow any changes I made to the left eye camera. If I smoothed that camera's path, I needed the right eye to follow suit, if I performed some dramatic transformation to that camera's path, perhaps extending its animation or re-animating an object that was part of the track while conforming the camera to that object's new path: I needed the right eye camera to keep up. If a cg element was being added, moving toward the camera, I needed to be able to selectively lock the convergence to "look at" that object's depth without diverting the cameras to actually look directly at it - similar to changing the focus depth.

It's all about control and instantaneous response, with a camera whose path is known with some degree of certainty and a second camera that will follow that one in a way that will produce realistic cg and will enable artists to quickly and accurately duplicate the second camera position when the original interocular distance and convergence information is not known.

Matrix multiplication, as a mathematical operation, isn't complicated - it's simple multiplication and addition, just repeated a number of times to generate the required result matrix. Since there are already more-than-ample tutorials online about how to actually *perform* matrix math (if you were cursed to do it by hand or develop procedures to support it in programming environments that don't already have matrix math support) I won't be covering that in detail. If my simple explanation doesn't quite do it for you, put "matrix multiplication" into Google if you're stumped.

I'm also going to avoid covering application in a specific language. Most recently, I was doing this in MEL for a project I'll discuss in a moment, but there are Python libraries for doing matrix math, TCL/tk support for it, PHP and Perl support - you'll rarely find yourself with no built-in or easily-added matrix support, though you may want to write (as I did) a number of routines to make it a little more accessible.

To the left, you can see the standard format of a translation matrix. This matrix (when multiplied by a coordinate matrix as represented on the right-hand side of the equation) will translate that coordinate into a new space, offsetting it by (tx, ty, and tz). In the typical way of matrix multiplication, the element in each row of the coordinate matrix [x y z 1] is multiplied by a column of the translation matrix, as shown here:

The rows of this matrix are then added together (in typical matrix multiplication fashion) to give the resulting (x',y',z') location.

But there's more to matrix transformation than simple translation. If you wanted to find the new (x', y', z') for a translation like this one, simple addition would be enough. But manipulating points in 3d space is rarely that simple!

Fortunately, it's just as easy to scale a point using matrix math! Always away from the origin - we'll talk about how to scale a point away from somewhere other than the origin shortly. All matrix operations work with a similar setup, so you'll get used to seeing a similar notation here.

This matrix is multiplied in the same fashion as the one we see above, rows against columns, with row sums producing (x',y', z') for the new location.

I'll admit, though. I don't use matrix math for scaling things very often. You know what I do use it for, though?

Rotating a point in space with respect to the origin! Isn't that exciting? I LOVE rotating things! Well, ok, so it's not that big of a deal - but when we start combining some of these things, it can turn a complicated object tree in your scene into a relatively simple expression.

I have to warn you, though, rotation is a bitch. Ever notice how your favorite 3d software has this whole "rotation order" thing? That's because if you rotate something 10 degrees in X, then 15 degrees in Y, it's not the same as rotating it in Y first and then in X. There's also a different matrix for each axis of rotation, so let's take a look. Same matrix math process as translation and scaling, but from this one we get rotation around the Z axis.

And now here:

That one rotates in X! And lastly, as you'd expect, there's a matrix for rotating around the Y axis:

Now, combining these matrix transformations together is as simple as multiplying the matrices with each other. Now, you build the series of multiplications in order from right to left, but they're carried out from left to right. For instance, for "zxy" rotation order, you would create an expression similar to the following: (I'll use MEL for this example: $xRot, $yRot, and $zRot are each 4x4 matrices that already contain transformation data for x, y and z rotation):

matrix $r[4][4] = $yRot * $xRot * $zRot;

Provided proper matrix variables are supplied, MEL supports basic matrix operations with some limitations that you'll find as you stretch your legs.

These can be strung together into much longer expressions generating much more complex matrices. To rotate an object about a point other than the origin, for instance, subtract the values of that coordinate from the coordinates of the object (transform it in {-cx, -cy, -cz} where {cx,cy,cz} was the center to rotate it around), perform the rotation, the transform it back {+cx,+cy,+cz}.

It may take some time learning to visualize and plan out a complex matrix transform - but what makes it powerful is the ability to combine any number of transformations into a single operation. Some basic trigonometry and a well-applied matrix transform can accomplish all kinds of things!

Matrix math is a bitch. And it's nigh impossible to find any good resources online. Every "transform matrix tutorial" or "matrix multiplication lesson" online explains in detail how to multiply matrices together.

That hasn't been my problem for about 25 years now. I get it. This is how you multiply a matrix with a vector. This is how you multiply two matrices together. Neither of those things actually *accomplishes* anything if you don't know what the data in those matrices represents or what adding, subtracting or multiplying them would do.

My problems always center around something more like this: I have a point at <10,20,30> with orientation <15,30,45>. Where is the point if I rotate it 15 degrees in y then translate it 100 units in the X axis?

What's screwed up is that I've so frequently solved this by doing trig that I know off the top of my head that pi/180 is estimated at 57.29577951. Some people pride themselves on the number of digits they know pi to: I find the radian conversion number to be far more handy. But for reference, pi to me is 3.14159265. Note the 8 significant digits behind the decimal number: can you tell what decimal significance I grew up programming in?

The thing is, I'm working on a number of tools for managing stereo cameras in Maya. I need to quickly determine from the transforms of one camera (derived from a track of live footage) the location and orientation of a second camera if we know (or can estimate or otherwise determine) the interocular distance (the distance between the eyes) and the convergence (how far in front of these cameras their line of sight intersects). Determining the angle of the second camera relative to the first is a straightforward bit of trig: think Pythagoras and arctangents and it'll come to you, or go find a good trig reference online - this part's easily found in a million places. Diagram that out for yourself, making an equilateral triangle with cameras at each base corner with convergence being the length of a line bisecting the triangle into two right triangles. If it's not immediately clear, work on it a bit: it might wake up parts of your brain that haven't seen the light of day since highschool.

The tricky bit is figuring out where a right-eye camera would be if it was offset along a line that isn't quite perpendicular to the left-eye camera.

I'm very nearly there - based on a given camera, I can find a point offset along that camera's X axis and apply a convergence factor to the resulting camera location by canting it back in along the Y. But rotating a known transform matrix by an additional value in the y axis *before* doing that x translation... still fussing with that bit. I can make that happen less elegantly - by actually transforming nulls through space in Maya - but I'm searching for the magical transformation matrix that'll make it happen in a simple series of math statements.

It's late. It'll probably be plenty clear to me in the morning.

UPDATE: Got it! Sleep did wonders - my tired brain just didn't quite get the matrix arrangement right before.  I'll write an entry this weekend covering concatenated matrix transforms.  Damn handy.  Damn powerful.

I was talking to a friend today about what I'm doing with regards to managing data through an animation pipeline using XML. The more I work with it and the farther I get into the project, the more flexible and powerful the whole thing seems. Of course the goal to doing the implementation in Python is that virtually every software package in the vfx industry is python-friendly - so once the core routines are written, everything from Nuke and pyShake (the python plugin for Shake - if you haven't seen it yet, check it out here) to Maya, Houdini and RealFlow will be able to make use of them. I think most places are doing that these days, with a few nods to TCL/tk here and there - but broadly supported scripting languages are King and open description formats like XML are Queen.

My friend marveled at how nice it would be if one day, a couple years from now, everything was able to talk that smoothly: that a character animated in Maya could be pulled into Houdini, for instance, as something other than an OBJ sequence or a separately rigged character that you had to tediously (or with a lot of specific coding) link to exported channel data.

I wonder if that interoperability thing will ever extend beyond each individual studio's implementation. Everybody has a way of getting software to talk amongst themselves, some solutions being more elegant than others, but when you invest in creating something as elaborate as this it becomes your own proprietary tool. If you develop a tool that an animator can take an animated character with a complex rig on it, arbitrarily select additional elements that were never *really* meant to be animated and animate them anyway, and the modeling team can modify the model and issue a new version of it - and the animation gets seamlessly transferred over to the new model, even able to be read into RealFlow, substituting a different set of low poly independent objects that are driven by the data in that XML file: you don't put that pipeline tool on the internet for everyone to download for free.

That tool becomes your secret weapon. As a studio with an investment in a powerful and unique proprietary tool, even charging for it may not mean as much to you as the edge you gain during the heat of production.

Being XML based and implemented in Python does put my current project a wee bit closer to being an open standard, though. Even Shake will take Python scripts now - and they're really powerful in it and getting more so as development continues. The readability thing for XML is a gigantic plus, and the way it represents data is great. I can build a module that will write out the translation of a locator in both world and local space, as a baked set (every frame has a value) and as a set of keyframes (values only for those frames where the value was explicitly set by the artist), as well as screenspace UV values - so the same XML file could reconstruct a scene for a lighter to light and render from or another animator to tweak the animation curves, or for RealFlow to drive low-poly proxy objects with to disturb a drifting mist, or for a compositor in Toxic to link an effect to. And it's all one XML file - not a half dozen formats (often multiple versions of each) and a hundred-unit sequence of geometry exports.