Originally posted on AltDevBlogADay:
The rest of software is moving into The Cloud, how come we aren’t doing the same with our tools and pipeline?
I love the cloud. Yes, I know it’s a buzz word for not quite revolutionary concepts, but I love it anyway. I love it for the practical benefit I get, and I love it for the technological possibilities it brings. It doesn’t just mean using web apps- it means using amazing applications that run in any browser on any platform, it means not worrying about storing data locally, it means a rich and expanding personal experience based on the connections between your data and everyone else’s.
And then I think about most of the pipelines I’ve seen and I wonder: what have we missed? Very often, we are building some of the most incredible and expensive games ever with incredibly shitty sets of tools. Why do we have essentially the same pipelines as we’ve had for the same 10+ years? (I recently finished a case study of Dark Angel’s pipeline, from 2001, which is remarkably similar to some I’ve seen recently). Game production has changed, but pipelines have not. We’re releasing games that get downloaded content (or are continuously updated like an MMO), and the amount of content is ballooning. Yet we’re still using essentially the same technologies and strategies as we were in 2001. There’s something to learn by looking at Cloud technologies and concepts, buzzword or not.
Can game pipelines, too, move into the cloud?
The one essential aspect of the cloud is its basis in service-based architectures. For the sake of simplicity and those unfamiliar, let’s say a service is a local or remote process that has some set of exposed methods that can be called by a client through a common protocol (JSON, XMLRPC, etc.). All other aspects of cloud technologies require this serviced based architecture. You couldn’t have the characteristic web apps if there was no service behind them. You couldn’t run the same or similar page on any platform and device if the work was happening on the client instead of the service. You couldn’t have a backend that automatically scales if the real work was happening in a Rich Client App (RCA) instead of in a service.
Could we build our pipelines with the same service-based approach (if not the always-there distributed-ness), and would we get similar results?
( ) ),--.::::::::::::::::::::::.
Yes, we can. But let’s consider what a service-based pipeline architecture would look like. The biggest change is moving nearly all functionality out of DCC apps, which are RCA’s, and into libraries that can be consumed by the services. This is what I’ve been doing for years, but I understand it may be a new thing for many people- but I guarantee you can do it and you’ll be better off because of it, not having to deal with buggy and monolithic DCC apps. These libraries/services can use headless apps behind the scenes if necessary, to do rendering or some processing or whatever (mayabatch.exe or whatever). Avoid it if you can, but you could do it.
The DCC and its UI’s, then, become very simple shells which just call methods on the service, and contain very little functionality of their own. The service does the processing and calls back to the client (and if the function can be done asynchronously, the user keeps working while the work happens in the background). The service can communicate to other remote and local services to do the work it needs to do.
Conceptually it is simple, but I promise you, the implementation will be complex. So the benefits better be worth it.
And they would be. The first thing you get is better abstraction between systems and components. We remove ourselves from the hacks and workarounds of programming in a DCC, and can instead concentrate on working in a sensible development environment and not have to worry about debugging in app or having to make sure all our libraries work under whatever half-assed and old implementation of python Autodesk provides. This results in being more deliberate about design decisions- not having a hundred pipeline modules available to you is actually a good thing, it forces you to get your dependencies under control, and you give more consideration to your APIs (I blogged about how server/client systems can be a useful exercise in abstraction).
These abstractions also give greater scalability. No problem moving your code between versions of your DCC, machine architectures, python/.NET versions, etc. It doesn’t have the ball and chain of DCC apps, because you’ve taken it all out of the DCC apps. Compare this flexibility in scalability to something like render farms- they usually have a very specific functionality and required software and added more functionality takes lots of engineering time. By having ‘normal’ code that can be run on any machine, you can distribute your processing to a farm that can tackle anything, and doesn’t require as complex systems or specialized skills to manage. This is the distributed processing capacity of cloud computing (in fact you could probably deploy this code to a cloud provider, if you had good server-fu).
These abstractions also lead to language neutrality. That’s right, I said it. I didn’t say it is a good idea, just that it’s possible. Just the same way the Twitter API has been wrapped in three dozen languages, your services should have an API using a common protocol like JSON, and many services and clients can communicate together. You’re not stuck using COM or marshalling data or any other number of bullshit techniques I’ve seen people do to glue things together. Your client can be anything- a DCC, a web app, a mobile app- you could even run it via email if you so desired, with zero change to the pipeline itself- only the client code you need to call it. And don’t forget hosting a web page in a library like Qt or .NET could also run the service.
This is software engineering as we tech artists and pipeline engineers should have been doing all along.
| | _________ |o|
| |___________| |
| _____ |
| DD | | V|
Let’s take a simple pipeline, like a character mesh exporter that includes an automatic LoD creator. In Maya (or Max, or XSI, whatever), the user just hits ‘export selected’, and it can transfer the mesh data and the Maya filename/mesh name to the Local Service.’ It can transfer the mesh data directly as a json object, or it can save it to an fbx file first and transfer the name of the fbx file, whatever- the point is that it isn’t data in the DCC, it’s data from the DCC.
At that point, Maya’s work is done and the user can go back to working while everything else happens in the background in other processes and machines. Awesome! Most (all?) DCC’s are still very single threaded so trying to do any real work in background threads is not practical (or stable…).
The Local Service sends the mesh data to some Remote Services to request the generation of some crunched and optimized LoD meshes. The Local Service can call an Asset Management Service with the scene filename/mesh name, to get the export path of the final mesh file. The Local Service can then do whatever it needs to do to ‘export’ the content: call some exe files, serialize it, whatever, it just needs to save the exported file to where the Asset Management Service said it should be.
The Remote Services can call back to the Local Service as they finish processing the LoD’s, and the Local Service can save them where they’re supposed to go as well. All of this without the user having to wait or intervene for anything, and without bogging down his box with expensive, CPU hungry operations.
| | |
| |====| | |
| |====| | |
| ___ | |
| | @ | | |
| --- | |
Is this complex? Yes. Is it possible for a technically competent team to do? Absolutely not. Pipelines are the bastard child of game technology, and it show- we have been doing the same crappy things for a decade. If we want to minimize ballooning costs of content development, develop robust pipelines capable of supporting games after ship with updates and DLC, and, let’s face it, work on some inspiring and exciting new technology, we’ll take pipelines to the cloud.