<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Blue Sky Tech Blog - Medium]]></title>
        <description><![CDATA[The Technology &amp; Engineering Behind Blue Sky&#39;s Animated Feature Films - Medium]]></description>
        <link>https://medium.com/blue-sky-tech-blog?source=rss----1d75ee699393---4</link>
        <image>
            <url>https://cdn-images-1.medium.com/proxy/1*TGH72Nnw24QL3iV9IOm4VA.png</url>
            <title>Blue Sky Tech Blog - Medium</title>
            <link>https://medium.com/blue-sky-tech-blog?source=rss----1d75ee699393---4</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Mon, 16 Nov 2026 20:44:41 GMT</lastBuildDate>
        <atom:link href="https://medium.com/feed/blue-sky-tech-blog" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Integrating Conduit in Houdini]]></title>
            <link>https://medium.com/blue-sky-tech-blog/integrating-conduit-in-houdini-5f77c7597bab?source=rss----1d75ee699393---4</link>
            <guid isPermaLink="false">https://medium.com/p/5f77c7597bab</guid>
            <category><![CDATA[pipeline]]></category>
            <category><![CDATA[conduit]]></category>
            <category><![CDATA[vfx]]></category>
            <category><![CDATA[houdini]]></category>
            <category><![CDATA[pdg]]></category>
            <dc:creator><![CDATA[Wayne Wu]]></dc:creator>
            <pubDate>Thu, 24 Sep 2020 15:27:00 GMT</pubDate>
            <atom:updated>2020-09-24T15:27:00.290Z</atom:updated>
            <content:encoded><![CDATA[<p>(Need a refresher on Conduit? Check out: <a href="https://medium.com/blue-sky-tech-blog/conduit-introduction-5f1134171b7">Conduit: Introduction</a>)</p><p>By the time I joined Blue Sky Studios in the summer of 2019, Conduit was already a mature piece of software: it had a robust API, Git-like CLI tools, and a set of established rules on how the pipeline data should be managed. However, the workflows around production work, and Conduit’s integration into DCCs, were still a work-in-progress. Even today, we strive to make Conduit easy for artists and TDs.</p><p>In the beginning, as part of the FX team, I was using the early Conduit tools in Houdini to try to develop FX workflows. However, it quickly became apparent that those tools didn’t exploit the power or proceduralism of either tool. Therefore, I decided to get my feet wet and untangle the bridge between Conduit and Houdini.</p><p>So what exactly was the problem?</p><p>The problem stems from the systematic change of using Conduit: <strong>no more file paths</strong>; <strong>everything is a <em>Product</em> and version controlled</strong>. This basically means that any node that deals with File I/O had to convert a Product to a path. For example, if you want to write a USD file, you would select a Product (i.e. <a href="https://medium.com/blue-sky-tech-blog/conduit-pipeline-resource-identifiers-4432776da6ab">PRI</a>), declare it as an Output to your Workspace, and the Output would contain the actual path of where the USD file should be written to. While artists can technically work with file paths directly, it requires extra work for them to manage the dependencies explicitly and correctly.</p><p>It was forgiving at first. There were only a few nodes that dealt with File I/O, so the solution at that time was tool-specific. But as the complexity of workflows grew, especially with <a href="https://www.sidefx.com/products/houdini/solaris/">Solaris</a> being able to read and compose USD files directly, more nodes had to communicate with Conduit directly. The process required first creating a wrapper-HDA then a Python wrapper-class that uses the Conduit API. It was a lot of unnecessary coding and could only be done by TDs. Different departments also had their own takes on how to talk to Conduit in Houdini, which only meant more pipeline divergence.</p><p>So I began the quest to find a solution to <strong>unify all the Conduit tools in Houdini</strong>. While USD is a vital part of Conduit, I tried to focus on the core principles of Conduit with the goal to build a system that is ultimately agnostic to file format and Houdini context.</p><h3>ProductPDG</h3><p>Before addressing the actual I/O issues, there was something more fundamental that I wanted to take care of. For a while, manipulations of Products required Conduit API or CLI directly. Things like committing and publishing assets (i.e. Products) were all done by artists through predefined GUIs without much ability to customize.</p><p>I wanted to change that as a first step to understanding the system. I wanted to <strong>bring Conduit closer to technical artists</strong>, and provide them a mechanism to manage Products at their own will, using PDG.</p><p>One of our GUIs already used PDG internally to export USD files and commit Products in parallel. However, all the PDG nodes and the PDG graph itself were set up in Python. At that time, I was studying PDG for some of our FX workflows like wedging. Since they were all intertwined with Products, I thought: why not expose the PDG logics to be more user-facing?</p><p>So we started exposing the few existing PDG nodes, such as commit, checkout, etc. and added a variety of new Product nodes that would complete them as a useful toolkit, known as ProductPDG. Each PDG node was wrapped as a TOP HDA, allowing the graphs to be built in Houdini directly. Furthermore, a definition was given to establish the relationship between PDG and Conduit: <strong>each work item represents a type of Product item</strong>, and the Product’s data is serialized into the work item’s attributes. These attributes can then be used to build the dependency graph, just like any other attributes in PDG.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/793/0*Ps3sX6y88fcEfPW3" /><figcaption>Users can easily traverse a graph and see the Product data by double-clicking on a work item.</figcaption></figure><p>The result was very promising. Departments like Crowds and Fur were able to build PDG graphs in Houdini to automate processes like fur attachments that can be scaled and parallelized across assets, without writing Conduit-related code. Meanwhile, our farm team was also developing our own <a href="https://www.sidefx.com/docs/houdini/tops/schedulers.html">PDG Scheduler</a>. That meant, when we eventually completed the custom Scheduler, we could send those graphs to the farm as simple as a switch from Local Scheduler to our own Scheduler.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/745/0*dS-wZ83CVon-KzMf" /><figcaption>An example PDG Graph that uses ProductPDG to create, process, and commit multiple Products.</figcaption></figure><h3>ProductIO</h3><p>To properly refactor and converge our artist-facing tools in Houdini, it came down to these basic principles of Conduit:</p><ul><li>A hipfile corresponds to a Workspace</li><li>A hipfile will read data from Input Products</li><li>A hipfile will write data to Output Products</li></ul><p>The goal is to provide flexibility in <strong>reading and authoring any kind of data</strong> (e.g. usd, vdb, bgeo etc.) for multiple Products, therefore we needed a solution that allows us to easily establish the input and output connections to Conduit from Houdini, hence the whole ProductIO framework. We started by defining what Input and Output should look like in Houdini.</p><p>An Input contains version information to indicate which version of the Product it is reading from. An Output has no version, but it is typically associated with some output process that generates data to the Output, which is then committed. In both cases, they inherit from a <em>ProductItem</em> object which means they are associated with a Product and therefore they share many similarities. This is a simple yet critical observation since they were previously treated and implemented as two separate entities. In Conduit, they are derived from the same object and thus ProductIO implements it as such. Back in Houdini, a node would either be an Input or Output and we would call the node a <strong><em>Productized</em></strong> node.</p><p>So how does one Productize a node?</p><h4>Product Properties</h4><p>Initially, I looked at creating a low level node that can be added to any HDA to Productize it. This is analogous to the Inheritance concept in programming, where Productization would be inherited by higher level nodes. However, this does not solve the problem of having to wrap around nodes just to Productize it, and not to mention, we would have to create low level Product nodes for each Houdini Context (i.e. LOP, SOP, etc.). The alternative that we ended up going with is to make Productization a <a href="https://en.wikipedia.org/wiki/Mixin#:~:text=In%20object%2Doriented%20programming%20languages,class%20of%20those%20other%20classes.">Mixin</a> rather than Inheritance. This means that <strong>Productization is an add-on feature to a node</strong>, which is done using <em>Product Properties</em>.</p><p>Product Properties are a collection of parameters that can be added to any node in Houdini to Productize it as an Input Node, Output Node. It works the same way as Houdini’s built-in <a href="https://www.sidefx.com/docs/houdini/props/index.html">Node Properties</a> which allow users to add additional spare parameters to expose a certain feature. In our case, by adding the Product Properties, the users now have access to the common Product parameters like a PRI field coupled with a Product Browser to easily browse for the desired asset in the Conduit database. Once a Product is selected, the <strong>I/O connection is managed automatically</strong> behind the scene, and an instance of the Input or Output is cached on the node to avoid unnecessary service calls if the Product has not changed. Using Product Properties, anyone can easily make Productized HDA, or Productize built-in Houdini-nodes regardless of their context.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*RSbWDt1C7L_GXXvu7Vnn5A.png" /><figcaption>Example of adding Product Properties (Input) to the Sublayer LOP.</figcaption></figure><p>The only attribute that would typically be needed from an Input or Output is the path to where the Product data lives. However, a Product can also store additional custom attributes that may be useful for specific workflows. That’s why instead of just caching the path, we store the whole PyObject on the node to have access to it at any point for any attribute. One of the default parameters that’s added to a node is an expression that will determine the path dynamically from the Product cache. It is important that the path, as well as any attributes, are determined dynamically so that they resolve accordingly when the PRI field is driven by an expression. This makes parameters programmable and enforces proceduralism, which we lacked before.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/750/0*dHLmT32P8Zq5KRUw" /><figcaption>Productized nodes have custom node info related to the Product it’s associated with.</figcaption></figure><h4>Output Graph</h4><p>As mentioned earlier, an Output typically has an output process associated with it, which can be anything from writing a USD file to rendering a sequence of frames. It is an optional but important characteristic of a Productized Output node that connects to the concept of <em>Output Graph</em>. If an Output node contains an output process, this process would be defined by a TOP graph within the node. We leverage the Target TOP Network parameter (a Node Properties collection shipped with Houdini) to promote a TOP graph with its fancy <a href="https://www.sidefx.com/docs/houdini/tops/ui.html">PDG UI</a> and associate it as the output process of the node. In short, each Output node will have a <strong>self-contained PDG graph</strong> to write out the desired data.</p><p>In addition to being able to run the output process per node, we also needed a way to run multiple output processes in parallel with specific execution dependencies. Indeed, this sounds exactly like what PDG is built for. Unfortunately, most artists were finding it overwhelming to use TOPs directly, so we were given the challenge to allow artists to execute them in-context of where they are working (mostly LOPs). This means that we had to translate a non-PDG interface implicitly to a PDG graph, which we call the Output Graph.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ZHj6LOferOQMhFOFy5A_aQ.png" /><figcaption>An overview of how different components interact with each other.</figcaption></figure><p>As a high-level concept, Output Graph is a generated master graph that runs multiple Output Nodes together based on specific dependencies. Since each Output Node already contains the PDG network that it needs, we reuse the same PDG network inside the Output Graph. Thus, it is basically <strong>a graph that contains multiple sub-graphs</strong>. The dependencies of the Output Graph is first determined based on implicit dependencies between outputs (i.e. what can or cannot be run together) and finally based on explicit orders defined by users through an interface.</p><h4>ProductIO Panel</h4><p>By standardizing all the Productized nodes and channeling them through the same framework, we were then able to build higher level tools to manage them. One such tool is the ProductIO Panel<em>.</em> As more nodes were being Productized, by artists and tool developers, we needed a way to see the <strong>Product-Node connections</strong> in one place and manage them. For this, we built a spreadsheet-style <a href="https://www.sidefx.com/docs/houdini/ref/panes/pythonpanel.html">Python Panel</a>, based on Houdini’s <a href="https://www.sidefx.com/docs/houdini/hom/nodesearch.html">node search</a> functionality, that will display all the Productized nodes in the scene with the option to filter based on properties like node type, node name, and PRI.</p><p>For all the Output nodes, this panel allows users to see all the nodes that are writing to an Output and build the Output Graph to run the output processes of selected nodes. It is where users can manage basic dependencies between nodes that are translated to the final Output Graph. To make it easier to tweak a few parameters on the nodes upon execution, we implemented a mechanism that allows parameters on Productized nodes to be tagged and dynamically added to the panel without having to extend the Qt code.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*AnRVrpme6TGjv3ymBPy0ZA.png" /><figcaption>ProductIO Panel for Outputs (Top) and Inputs (Bottom).</figcaption></figure><p>Finally, since version control is fundamental to Conduit workflows, the panel also allows users to commit multiple outputs and manage the versions of all Input nodes. While we have a Qt interface built for Conduit as a standalone application to manage a user’s workspace, ProductIO Panel is specifically meant to allow users to visualize and manage the Conduit dependencies <strong>at the node level within the scope of a scene</strong> (i.e. hipfile).</p><h3>Future Work</h3><p>ProductIO has greatly simplified the process of reading and writing in Conduit for Houdini, and streamlined most of the tools that are now used in production for our upcoming feature film. Nevertheless, it is actively evolving as we look for areas to improve upon. A lot of the current design is driven by hiding the unfamiliarity of new technologies and concepts away from users and bringing back as much of what artists were used to, in hopes of a smoother transition, but sometimes at the cost of a truly elegant system. This translates to technical debt and burden that can be unhealthy to a pipeline.</p><p>As artists become more comfortable with Conduit, we may look into reducing the parameters in Product Properties to reduce front-end complexity. Ultimately, the fewer parameters users have to worry about, the better. A lot of the parameters are also currently tied together implicitly behind the scene which makes them rigid in implementation. On the other hand, PDG will continue to be an integral part of our Houdini workflows, therefore we may start transitioning our workflow to be more TOP focused and empower artists to take full control of it with the help of ProductPDG.</p><p>We look forward to sharing more fun stuff that we’ve been doing in Houdini, especially with Solaris/USD! Stay tuned!</p><h3>Acknowledgment</h3><p>Much love for all the artists and developers who have helped me design and test the system, especially my awesome teammates Kenji Endo and Chris Rydalch!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5f77c7597bab" width="1" height="1" alt=""><hr><p><a href="https://medium.com/blue-sky-tech-blog/integrating-conduit-in-houdini-5f77c7597bab">Integrating Conduit in Houdini</a> was originally published in <a href="https://medium.com/blue-sky-tech-blog">Blue Sky Tech Blog</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[A Rose By Any Other Name]]></title>
            <link>https://medium.com/blue-sky-tech-blog/a-rose-by-any-other-name-4b569309b575?source=rss----1d75ee699393---4</link>
            <guid isPermaLink="false">https://medium.com/p/4b569309b575</guid>
            <category><![CDATA[user-experience]]></category>
            <category><![CDATA[animation]]></category>
            <category><![CDATA[naming-conventions]]></category>
            <category><![CDATA[vfx]]></category>
            <category><![CDATA[programming]]></category>
            <dc:creator><![CDATA[David Young]]></dc:creator>
            <pubDate>Tue, 21 May 2019 17:16:41 GMT</pubDate>
            <atom:updated>2019-05-21T17:16:41.569Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/409/1*eKMxPM_zYWTPC0xmODHruw.png" /><figcaption>Are UUIDs really such a bad idea?</figcaption></figure><p>“Decades and decades of using different pipelines and I still can’t just rename an asset!” an exasperated VFX Supervisor once vented to me. “<em>Why is this so hard?</em>”</p><p>I mean, shouldn’t it just be a matter of changing the file name? Or a directory? Or maybe tweaking a row in a database somewhere? Easy peasy lemon squeezy, right? Well, no. In fact, to quote the film <em>In the Loop</em>, it’s “difficult difficult lemon difficult.”</p><p>Naming things well is widely accepted as a challenge, but <em>renaming</em> things poses its own set of difficulties.</p><ul><li>Each production asset needs to have a unique name which identifies exactly one asset.</li><li>Throughout the pipeline, this unique name will be used to refer to that asset in order for everyone — every computer and every human — to agree on which specific asset is being talked about.</li><li>Changing the asset’s unique name in one place will break references anywhere else that is still using the old name.</li></ul><p>And yet, here’s the kicker…</p><ul><li>People often want to change the names of things.</li></ul><p>So, sure, that VFX Sup could have changed the name of the asset file or directory from “sofa” to “couch” or something, but then every reference to “sofa” throughout the show’s production data would be broken and production management would have been apoplectic that all work on “sofa” seemed to have suddenly ground to a halt and unscheduled work on something called “couch” was now skewing their planning scenarios. All that trouble just because a human preferred one word instead of another.</p><p><strong>Let the Computers Win</strong></p><p>Computers would be perfectly happy if production assets were only ever referred to by Universally Unique Identifiers (UUIDs). For example, instead of “sofa” or “couch”, 74fbd636–4fc5–11e9–91a2-ecb1d74481b4 could be referenced everywhere throughout the lifetime of the show and would always refer to the same thing. But then that VFX Sup would be complaining about how he keeps having a hard time differentiating 74fbd636–4fc5–11e9–91a2-ecb1d74481b4 from e67339d0–4fc5–11e9-b769-ecb1d74481b4 when he sees them embedded in files. It’s a similar case to how networks don’t mind speaking in the language of IP numbers, but users much prefer having DNS so they can speak in the plain language of URL names. Considering the tempo of production, sometimes a human needs to be able to quickly open a file, read it, and have it make sense. Perhaps “human readable” should be a consideration, but a consideration which drags in a new set of difficulties.</p><p><strong>No, Wait, Let the Humans Win</strong></p><p>The term “reference” means a thing that refers to something else. That other thing that is being referred to is called a “referent”. It’s like a finger pointing at the moon: the finger is the reference and the moon is the referent. A hexadecimal string can remain immutable because it’s only utility is being a pointer to something else. It’s a reference to a referent. That’s all it does. The reference doesn’t carry any extra meaning in or of or about itself. It just points.</p><p>However, human language is much more complicated than fingers or strings of hexidecimal. Words carry additional information about themselves, not just about what they refer to. In the fancy terminology of semiotics (the study of signs), the pointing finger is called a “signifier” and the moon is called the “signified”. What the signifier points to is its most basic level of meaning, what’s called its denotation. But the signifier can also have secondary meanings attached to it, surrounding it like a cloud or a web of other ideas. These are called connotations. Consider the differences between these asset names:</p><ul><li>couchA</li><li>Jennifers_couch</li><li>dilapidatedCouch</li><li>couch_leather_overstuffed</li><li>heroCouch</li><li>davenport</li><li>cuochA</li></ul><p>Each name gives a human more <em>hints about that thing</em> than just where to look for its files. The names themselves hint about the kind of couch or its condition or its owner or its material or its importance. (That last name even hints that someone types with fat fingers!) Computers don’t care about these connotations, but people find them really useful and helpful.</p><p><strong>Okay, Let the Humans Win But Be Strict With Them</strong></p><p>If we want the advantage of meaningful, human readable names, we could institute policies and processes that forbid renaming. We could insist that whoever names something is taking full responsibility for establishing a permanent, irrevocable name. So, they should be sure to, as the old carpenter adage goes, “measure twice and cut once.” No take backs. No do-overs. The downside of this option is that your coworkers will hate you when one of them invariably makes a minor mistake and it can’t be fixed. And, unfortunately, lots of things can change during the lifecycle of a show.</p><p><strong>Alright, Let the Humans Win But Be a Little More Forgiving</strong></p><p>We could institute a system where names are permanent and immutable, but we allow for new names to point to already named things. Someone could create the asset “cuoch”, realize their mistake, and create a new name “couch” which points back to the old name “cuoch”. The old name and the new name would be co-referential. Anywhere the old name was used would still work, it would just be ugly, and the new name could slowly propagate throughout the rest of the show. There are two problems with this approach. Aside from the general confusion of having a single asset referred to by multiple names, you have burned the old name so that it can never be used again in the future. If the character “ashley” is changed to “ashanti”, we can never add a <em>new</em> character named “ashley” because that name is technically already being used.</p><p><strong>Fine, Let the Computers Win But Let the Humans <em>Think</em> They Win</strong></p><p>We could use UUIDs for all assets but then associate a unique human readable label with each one. The label could be changed to different values without affecting any of the references throughout the production data, because the production data would use the human unfriendly UUIDs for their references. People still won’t be happy seeing hexadecimal strings whenever they crack open a file and try to read it, but maybe we can get away with that if we make them a tool that easily dereferences those UUIDs to the current label and hide the UUIDs from them whenever possible everywhere else.</p><p><strong>Making the Hard Decisions</strong></p><p>There is something of a fault line which runs between production management and artists on the floor. Each side has their own needs, workflows, and sometimes even vocabularies. Technology straddles that fault line. Here at Blue Sky Studios, production management uses Shotgun to schedule and track all production work. However, we have been writing our next generation pipeline, Conduit, to manage the underlying production data. Naming changes on one side have ripple effects on the other side. What this means for Conduit is that naming choices made in Shotgun will become embedded — or, perhaps, fossilized — in our Pipeline Resource Identifier (PRI) strings which will, in turn, end up in production data files. Making these PRIs semi-human readable was chosen over using more flexible but less friendly UUIDs. We may revisit the need for name forwarding, name labels, or aliases of some kind in the future, but for now we’re encouraging disciplined naming. There’s no perfect solution. All anyone can do is try to make the most number of people as happy as possible, as much of the time as possible.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4b569309b575" width="1" height="1" alt=""><hr><p><a href="https://medium.com/blue-sky-tech-blog/a-rose-by-any-other-name-4b569309b575">A Rose By Any Other Name</a> was originally published in <a href="https://medium.com/blue-sky-tech-blog">Blue Sky Tech Blog</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Learning to Design]]></title>
            <link>https://medium.com/blue-sky-tech-blog/learning-to-design-42ef7779f675?source=rss----1d75ee699393---4</link>
            <guid isPermaLink="false">https://medium.com/p/42ef7779f675</guid>
            <category><![CDATA[application-development]]></category>
            <category><![CDATA[design]]></category>
            <category><![CDATA[interface-design]]></category>
            <category><![CDATA[ux]]></category>
            <category><![CDATA[web-development]]></category>
            <dc:creator><![CDATA[Jennifer Brola]]></dc:creator>
            <pubDate>Mon, 19 Nov 2018 18:55:42 GMT</pubDate>
            <atom:updated>2018-11-20T20:48:14.163Z</atom:updated>
            <content:encoded><![CDATA[<h4>Creating interactions between users and technology.</h4><blockquote><em>“Design is a plan for arranging elements to accomplish a particular purpose.” Charles Eames, Interview with Madame L’Amic at the Musée des Arts Décoratifs, Palais de Louvre in 1972.</em></blockquote><p>While the labels of design and designer are culturally linked to pre-production art, technologists fit the term in a different way. In my role at Blue Sky Studios, the design disciplines (with regards to digital experiences) are fused together, incorporated under the title of <em>Production Technology</em>. Each new digital tool presents an opportunity for interface design (IxD). Each time we modify a user interface (UI), we’re changing the conversation between the user and the machine. We’re designing the user experience (UX). Ultimately, we’re designing a portion of whether end users have a “good day” or a “bad day,” whether they’re generally satisfied or consistently annoyed.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/590/1*flpWg7HC4__2pUn_Cb2POg.png" /><figcaption><em>Image Credit: </em><a href="http://upload.wikimedia.org/wikipedia/de/4/41/Interaction-Design-Discipli.png"><em>“Interaction Design Disciplines”</em></a><em>, Wikipedia. </em><a href="https://creativecommons.org/licenses/by-sa/2.0/"><em>Creative Commons 2.0</em></a><em>.</em></figcaption></figure><p>I didn’t always see the correlation between making a product and crafting an experience. For my entire college adventure, I’d worked multiple, overlapping jobs involving digital content: brand-building sites, advertisements, and (eventually) content and information management systems. By the time I was hired at Blue Sky Studios, I had a full portfolio and years of hands-on experience. However, while my design foundation was solid, I didn’t see digital media as an interactive <em>experience. </em>I wouldn’t make that realization until later, in the middle of my dissertation. As I researched social media’s impact on attitudes and culture, I coincidentally discovered theories and rules governing everyone’s experiences with digital media.</p><blockquote><em>“Making something the boss wants and making something the customers want are not automatically the same thing.” -Adam Judge, “The Little Black Book of Design”</em></blockquote><p>How do you delight people with a new feature? How can you confidently predict adoption? I looked for ways to learn more, that could fit my packed schedule, and wouldn’t require wheelbarrows of cash. That’s when I came upon the <em>Interaction Design Foundation</em>, an educational platform for technology designers. My first course (of many) was “<a href="https://www.interaction-design.org/courses/psychology-of-interaction-design-the-ultimate-guide">Psychology of Interaction Design</a>,” which digested content from resources like “The Design of Everyday Things” into 11 weeks of instruction, 10–20 lessons per week with mini-quizzes along the way. Unlike other platforms, testing leaned heavily on short answer and essay questions, and grades were respectfully permanent.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/992/1*8ohNN8nBtrnv0giRZY8HeQ.png" /><figcaption><em>A slide from our weekly Paper Jam sessions.</em></figcaption></figure><p>It was challenging to juggle the course material with my other responsibilities. However, the “no time limit” approach was a significant benefit, as it gave me an opportunity to leverage what’s called “the protégé effect.” I’d cycle through the material, and once a week, I’d try explaining it to my coworkers over lunch (using visuals and academic papers I’d cobbled together from various other sources). Nothing helps you stay focused quite like face-to-face accountability! We would chat about sensory perception, cognitive walkthroughs, and heuristic evaluations, referencing software already in use. We weren’t just evaluating user interface design, we were analyzing experiences based on established principles.</p><p>The meetings were called “<em>Paper Jam</em>,” a nod to an informal discussion (“jam”) about published research (“papers”), and a homonym for edible “jam,” its champion food. Alternate lunch hours were reserved for its sister meeting, “<em>Cheesy Code</em>,” which involved actual cheese! Both were collaborative learning opportunities, but “<em>Paper Jam</em>” was more focused on academic study. We projected slides, shared handouts, discussed real-world applications, and scribbled ideas on the whiteboard. Over time, the assortment of topics favored human computer interactions (HCI), and eventually the meeting became the nesting place for interaction design (IxD) reviews. From week to week, attendees from various departments would drop into the mix, offering their observations and participating in the discussions.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*80-Xmr9UlRfqFdyqkhdTPQ.png" /><figcaption><em>Interactions mapped in an Adobe XD prototype.</em></figcaption></figure><p>What’s the takeaway? Blue Sky Technology is a fellowship beyond frameworks and services. We’re <em>designers </em>creating software that aspires to be usable as well as useful, evaluating each tool from the perspective of the consumer. We’re creating end-user experiences, we’re designing “good days,” and we’re incorporating many disciplines to do it. When an audience watches films like Spies in Disguise, they’re watching a creation touched by many hands, each striving to contribute one-hundred percent. The time we’ve spent learning our craft, understanding its impact, and applying that knowledge is our contribution. That said, there’s always something new to learn, some new thing to explore, because regardless of the form it takes — design is everywhere.</p><p><em>Dr. Jennifer Brola has been a Production Engineer for over six years at Blue Sky Studios. Connect with her on </em><a href="https://www.linkedin.com/in/jenniferbrola/"><em>LinkedIn</em></a><em> and check out Blue Sky’s new </em><a href="http://blueskystudios.com/films/ferdinand/spies-disguise/"><em>SPIES IN DISGUISE trailer</em></a><em>!</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=42ef7779f675" width="1" height="1" alt=""><hr><p><a href="https://medium.com/blue-sky-tech-blog/learning-to-design-42ef7779f675">Learning to Design</a> was originally published in <a href="https://medium.com/blue-sky-tech-blog">Blue Sky Tech Blog</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Non-Noxious Nomenclature]]></title>
            <link>https://medium.com/blue-sky-tech-blog/non-noxious-nomenclature-977a173c6826?source=rss----1d75ee699393---4</link>
            <guid isPermaLink="false">https://medium.com/p/977a173c6826</guid>
            <category><![CDATA[naming]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[user-experience]]></category>
            <dc:creator><![CDATA[Ryan Bland]]></dc:creator>
            <pubDate>Mon, 29 Oct 2018 14:39:59 GMT</pubDate>
            <atom:updated>2018-10-29T14:41:12.615Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*HDGiVO7L1F76-RNRmiIjOw.png" /></figure><p>As an animation pipeline and tool developer, I name things; a <strong>lot</strong> of things. To date, I’ve named countless variables, thousands of functions and classes, hundreds of production assets, dozens of tools, two pipelines and one company. I’m passionate about nomenclature, and I strive to give each name its due consideration. In spite of that — or perhaps because of — I regret so many of them. I have chosen names that were disregarded by the user base in favor of other nicknames. I’ve had names become horrendously inaccurate after refactoring. I have chosen names no one knew how to pronounce. I once spent hours debugging a missing shadow only to finally realize I had misspelled the light’s name as “dummmyLight”.</p><p>There is something <a href="https://en.wikipedia.org/wiki/True_name">magic about names</a>. Ascribing a word to a thing anchors it to reality. Perhaps my favorite example of this is “deja vu”. It’s an ethereal and transitory experience but because it has a name we easily identify it when it happens. If you are not familiar with <a href="https://en.wikipedia.org/wiki/Linguistic_relativity">linguistic relativity</a> (a.k.a. the Sapir–Whorf hypothesis) go see <a href="https://www.washingtonpost.com/national/health-science/the-science-behind-the-movie-arrival/2016/11/14/5e344114-a6a7-11e6-ba59-a7d93165c6d4_story.html?noredirect=on&amp;utm_term=.cbc6e592ba28"><em>Arrival</em></a> already.</p><p>To my fellow developers I say: <strong>names matter</strong>. From the most local variables to the most global initiatives. Our role requires us to grapple with complex and frustratingly abstract concepts. By naming them, we organize these concepts in our own mind as well as the minds of our organic and electronic colleagues. To me, words are a coat rack. We hang our comprehension on them as well as our memories and feelings. Broken coat rack = messy floor.</p><p>Okay, enough with the philosophical flim-flam. What have I learned from all those mistakes? To avoid turning this into a click-bait article, here is an <em>unnumbered </em>list of tips to help you denominate your work. These tips are intended for developers writing code and authoring tools, but most will be applicable in a general case.¹</p><h3><strong>Use Established Terminology</strong></h3><p>Most things have a name already. If you were excited to go name everything, sorry to burst your bubble. For goodness sake, do not invent a new name for something that already has an established moniker. For those in the animation industry, here are a few references to help you get started:<br><a href="http://www.filmsite.org/filmterms.html">Film Terms Glossary</a><br><a href="https://animcareerpro.com/2015/06/12/animation-terms-common-studio-term/">Animation Terms</a></p><p>Along those same lines, know your data structures and apply their names when appropriate. A simple example: a two dimensional view of assets would be an <em>AssetTable</em> while a hierarchical view would be an <em>AssetTree</em>. Rather than <em>A*</em> down this rabbit hole I’ll just leave this here:<br><a href="https://en.wikipedia.org/wiki/List_of_data_structures">Data Structures</a></p><h3><strong>Use a </strong><a href="https://www.thesaurus.com/browse/thesaurus?s=t"><strong>Thesaurus</strong></a></h3><p>Sometimes you will find your terminology feels just a little off. When this is the case, try cracking a thesaurus to find terms that have the closest conceptual match to what you are describing. Is that collection of things an “assembly”, “batch”, “bundle”, or “convocation”? … maybe not that last one.</p><h3><strong>Use Namespaces and Be Brief</strong></h3><p>Plan your namespaces as a team and establish conventions wherever you can. If you are a programmer writing code inside of a certain namespace, do not repeat the namespace in the name of the data structures in it. In general, err on the side of brevity. It improves code legibility and your carpal tunnel will thank you.</p><h3><strong>Avoid Collisions and Overloading</strong></h3><p>When choosing names for code, avoiding collisions is mandatory. On top of that, there are other potential collisions to consider. For example, if certain terms are used as file system tokens, will they collide with other file system tokens?</p><p>If you are creating a command line tool, is the name used by a command installed now or in the future? Is there a logical short alias available? Will those names work nicely with tab completion?</p><p>For bigger initiatives — such as potentially open-source projects — you should also think about global issues like domain name, GitHub or package system availability.</p><h3><strong>Be Consistent Between Code and Interface</strong></h3><p>When your code is exposed to the outside world in the form of a GUI, CLI, API or at least documentation, use the same nomenclature in those interfaces that you established in the code. If you find the nomenclature in the code does not translate well to human-friendly language in the interface, that’s a good sign it should be reconsidered. This will help future developers (including yourself) work backwards from the interface to grasp the code.</p><h3><strong>Avoid Puns and In-jokes</strong></h3><p>These will be the names that morph into unpleasant nicknames when the software breaks down. Leave this domain to the small businesses like Back to the Futon and Pane in the Glass. So clever. Sure it might get that new restaurant a little more foot traffic but it attracts mostly groans from colleagues followed by chronic amnesia regarding what the name referred to in the first place.</p><h3><strong>Consider Future Features</strong></h3><p>Future changes to your software may lend it a new purpose or new users. If you author an awesome new tool that builds scenes for lighting, you might name it “Lighting Scene Builder” an excellent no-nonsense name. Now suppose, after a few small updates, it also can be used by animation to build their<em> </em>scenes. If you used the word “lighting” throughout your code you have a problem.</p><p>Try to anticipate this kind of generalization or feature creep in your naming. While you’re at it, send me your best stock tips.</p><h3><strong>Get an Outside Opinion</strong></h3><p>To be sure your names encapsulate your ideas, present them to someone else. If you are working as part of a team, try to go outside of that group to get a reaction from someone unfamiliar with the project. It’s like <a href="https://www.youtube.com/watch?v=U6erOrgptYc">that one guy</a> said, “If you can’t explain it simply, you don’t understand it well enough.”</p><p>Companies choosing a new brand name will routinely hire <a href="https://www.brandsareboring.co/naming.html">naming agencies</a> to help. That’s a little extreme in the case of a for-loop iterator, but even if your users are exclusively in-house, they are your customers and your software needs a good brand.</p><h3><strong>Know your Name Types</strong></h3><p>It helps me to think of names in the following meta-name taxonomy.</p><p><strong><em>Descriptive</em></strong><em>: 3d Studio Max, Adobe Character Animator<br></em>Tell it like it is. For developers of course, the majority of your names should fall here.</p><p><strong><em>Proper</em></strong><em>: Maya, Houdini, Arnold, Jenkins<br></em>These are names with no denotation. Still, notice the examples have strong connotations to establish an idea in your mind about the software’s characteristics.</p><p><strong><em>Words</em></strong><em>: Substance, Nuke, Shotgun, Blender<br></em>These are names from familiar words with a denotation. These can be effective at conveying the function of the software and tend to be brief. I also count spelling corruptions in this group.</p><p><strong><em>Acronyms &amp; Abbreviations</em></strong><em>: Gimp, OSL, SVN, OIIO<br></em>I won’t insult you by explaining what an acronym is.²</p><p><strong><em>Portmanteau</em></strong><em>: MySql, RenderMan, BitBucket<br></em>These are names formed by pushing two other words together to form a single new word. These do not always lend themselves to pronunciation, but notice that the simple act of ramming two words together transforms them into something new.</p><p><strong><em>Resurrected &amp; Foreign</em></strong><em>: Alembic, Atelier, Krita<br></em>These are names from native or foreign words that are unfamiliar to the user-base. This route gives you more discretion to choose a name that is pleasing to the ear. Just be careful that people know how to pronounce it.</p><p><strong><em>Nonsense</em></strong><em>: waf, git, Nvidia<br></em>When all else fails, make something up. This has the advantage of avoiding all collisions and can be kept fairly short. I mean, where else do words come from.</p><p>Most of all, it’s less important you find the perfect name for your constructs and more important you use those names consistently. You are not a troglodyte so stop using words like a cudgel and start using them like a scalpel.³</p><p><em>¹ Do not use these tips for naming children.<br>² Acronyms are an abbreviation formed from the initial letters of other words and pronounced as a word.<br>³ If you are a troglodyte, please excuse the hate-speech.<br>⁴ </em><a href="https://demangler.com/"><em>Bonus footnote</em></a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=977a173c6826" width="1" height="1" alt=""><hr><p><a href="https://medium.com/blue-sky-tech-blog/non-noxious-nomenclature-977a173c6826">Non-Noxious Nomenclature</a> was originally published in <a href="https://medium.com/blue-sky-tech-blog">Blue Sky Tech Blog</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Annual Blue Sky Hackathon]]></title>
            <link>https://medium.com/blue-sky-tech-blog/the-annual-blue-sky-hackathon-a8b736013c69?source=rss----1d75ee699393---4</link>
            <guid isPermaLink="false">https://medium.com/p/a8b736013c69</guid>
            <category><![CDATA[machine-learning]]></category>
            <category><![CDATA[hackathons]]></category>
            <dc:creator><![CDATA[Rebecca Hallac]]></dc:creator>
            <pubDate>Tue, 16 Oct 2018 14:23:29 GMT</pubDate>
            <atom:updated>2018-10-16T14:28:25.866Z</atom:updated>
            <content:encoded><![CDATA[<p>Growing and maintaining a culture of creativity and innovation is crucial to movie making. One way the Blue Sky technology departments foster this culture is through our annual hackathon. A hackathon is a social coding event in which engineers come together to create and build out-of-the-box ideas in a short amount of time. At Blue Sky, we hold a 48 hour long event filled with snacks, food, caffeine, more snacks and fun!</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*4UAdTLe83xs36J8DLLxzLQ.jpeg" /></figure><p>Starting on a Wednesday afternoon, our teams worked well into the night — and the following night — all with the goal of demoing their work on Friday. Teams were made up of members from Production Engineering, the Technical Directors, Research and Development, and Systems. Together we collaborated to create some really fun and innovative projects.</p><p>Overall 8 teams participated and demonstrated their work. Here’s a look at 3 award-winning entries.</p><h3>ComicAI</h3><p><em>Eszter Offertaler, Grace Kumagai, Michael Reed, Adam Burr</em></p><p>Our team identified a comic dilemma: we want to write comics, however, minor problem is we cannot draw. Luckily, there’s a lot of great artwork already out there, such as the graphic novel <em>Nimona</em>, the basis for our 2020 release! What if we could leverage that preexisting art and throw our dialog on top of it? On the night of the Blue Sky hackathon we did just that!</p><p>Our comic art retargeting application had two phases: offline preprocessing, and online generation.</p><p>During preprocessing, we built a library of edited and labeled comic panels from the original <em>Nimona </em>pages. We used OpenCV to segment the pages into individual panels, and then a combination of Mathematica and the Google Cloud Vision API to locate, extract, and mask the text from the speech bubbles. To maintain comic coherence, we gauged the emotional tone of each bubble using the IBM Watson Tone Analyzer, which returns a weighted list of possible sentiments, e.g. ‘Confident’: 0.96, ‘Joy’: 0.54, etc. This static library of panels and metadata was stored and reused for fast, online comic generation.</p><p>During comic generation the user supplied a text-only script file. Each line of dialogue from the new script was again sent to the Watson Tone Analyzer. Using the resulting sentiments, we selected panels from our library, row by row, that collectively matched the sentiments of the new script and had the correct number of speech bubbles. We then composited the new dialogue into the empty speech bubbles using Pillow, wrapping and aligning the text to match the bubble shapes. To preserve the feel of the original comic, we used a custom <em>Nimona </em>font made in Calligraphr. Finally, we assembled the panels into a cohesive page, again using Pillow, applying geometric constraints to maintain visual appeal.</p><h3>Dark Sky Yolo</h3><p><em>Pranay Patel, Danny Rerucha, Georgi Todorov</em></p><p>A lot of images are generated at our studio every day, and regular review of these images is the engine that propels our production forward. It’s important for us to always be able to find the imagery we need whenever we need it. In service of this, all frames that are rendered are automatically registered with our media service with the appropriate metadata, and users may optionally add arbitrary tags to any media items they like.</p><p>This system works well, but it has a few shortcomings. Most notably, adding tags is a manual process, so if someone forgets to add relevant tags, expected media items might not appear in search results.</p><p>Dark Sky Yolo is a project that uses machine learning to automatically identify objects within a frame and apply the appropriate tags for more robust media searchability. We achieved this by incorporating an open source real-time object detection system called <a href="https://github.com/pjreddie/darknet">YOLO</a> into our media submission process. YOLO comes pre-trained with a small number of classifiers that represent basic nouns like person, car, dog, and bicycle. Thanks to this pre-trained dataset and a very simple API, we were able to start generating automatic tags almost immediately.</p><p>Generic tags like “car” applied consistently across an entire show can be really useful, but a cool thing about working in CG animation is that we have perfect data for training new Blue Sky-specific classifiers capable of detecting and tagging specific assets (e.g.,“ferdinand” instead of just “bull”), or even specific revisions of assets. New classifiers are trained by curating many images that contain the object you want the algorithm to detect, and the turntable images that are generated for assets during our asset publish process are perfect for this task.</p><p>In the end, we were able to create a simple and non-intrusive automated tagging system that has a lot of potential to be expanded on in the future!</p><h3>Slack Shot</h3><p><em>Alena Volarevic, Jake Richards, Steven Song, Tracy Priest</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*P8-0pjbDCr6VCM3J" /></figure><p>We are constantly sending each other feedback on the imagery that we create at Blue Sky. On top of comments, this feedback is often most helpful in the form of draw overs on top of imagery or video captures. Having recently integrated Slack as a key part of our communication pipeline, we wanted to see how we could harness the tool for our visual feedback needs.</p><p>Before this tool, artists would have to screen shot, annotate and upload each image in separate steps which is timely and inconvenient. Slackshot is an application that streamlines the process of communicating these visual feedback directly from the software the artists use to create these drawovers (RV) to Slack.</p><p><strong>We are planning on open sourcing more of our hackathon projects, so stay tuned for a later blog post!</strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a8b736013c69" width="1" height="1" alt=""><hr><p><a href="https://medium.com/blue-sky-tech-blog/the-annual-blue-sky-hackathon-a8b736013c69">The Annual Blue Sky Hackathon</a> was originally published in <a href="https://medium.com/blue-sky-tech-blog">Blue Sky Tech Blog</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[My Summer at Blue Sky Studios]]></title>
            <link>https://medium.com/blue-sky-tech-blog/my-summer-at-blue-sky-studios-f0d9b68bca53?source=rss----1d75ee699393---4</link>
            <guid isPermaLink="false">https://medium.com/p/f0d9b68bca53</guid>
            <category><![CDATA[vfx]]></category>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[animation]]></category>
            <category><![CDATA[rendering]]></category>
            <category><![CDATA[internships]]></category>
            <dc:creator><![CDATA[Emily Vo]]></dc:creator>
            <pubDate>Thu, 06 Sep 2018 15:27:57 GMT</pubDate>
            <atom:updated>2018-11-14T20:17:30.884Z</atom:updated>
            <content:encoded><![CDATA[<p>“We expect you to ask a lot of questions!” was what my mentors told me on my first day as a Blue Sky Studios Production Engineering intern. This was my first studio internship and to say I was nervous, is an understatement. I remember my first task was to find all human characters with fur in our upcoming movie using the Shotgun Python API. I didn’t know Python at all, and had no experience with Shotgun, but my mentors, Becca Hallac and Marley Gilb, encouraged and taught me that it was okay to be confused and to ask questions; it meant I was learning. As a result, I learned a lot this summer.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1020/1*fLbJLn1AutO78ZuEOwKqsQ.png" /><figcaption>Scene Health UI in Maya</figcaption></figure><p>My internship provided a lot of flexibility on how to approach tasks, which allowed me to challenge myself and to pick which tools I wanted to learn. As a result I worked on an array of different tools and tech. One of the projects I worked on was Asset Health, a system that allows users to fetch important metrics to diagnose performance issues in our assets as part of the new pipeline mentioned in the 2018 SIGGRAPH talk <a href="https://s2018.siggraph.org/presentation/?id=gensub_405&amp;sess=sess294">Achieving and Maintaining Real-Time Rigs</a>. For <em>Spies in Disguise </em>(2019), my mentors helped me design and implement a “Scene Health” Maya plugin to display Asset Health metrics for all assets in a layout scene file. When I was building the Scene Health Maya plugin, I got to work directly with Jerril Yoo, a Technical Director supporting the layout department, who was very patient in explaining all of the desired features and needs of the tool. Together we created a user experience that displays the data in a meaningful way to artists. I then proceeded to build the tool in PyQt. The projects I worked on were relevant to production and I was incredibly proud to see my projects being used.</p><p>For my final project, I worked on converting the Moana Island scene geometry to Pixar’s open source Universal Scene Description (USD). This will allow the scene to be rendered using RenderMan. Tim Hoff, a Technical Director in Production Technology, and Chris Rydalch, an FX Technical Director, became my point people for my Moana conversion project. Chris took the time to meet with me to explain how to get started, which was probably the most daunting part. Tim taught me how to optimize my USD files with point instancing. He then helped me diagnose a massive bug in my obj loader that caused a single tree’s USD file to blow up to 100GB which subsequently slowed the runtime of my script. Even after running overnight, it still wasn’t able to finish parsing the data for a single tree. With Tim’s help, no USD file for any element in the scene exceeded 1GB in size, and my script was able to process all of the scene’s elements in 40 minutes. Sally Kong, a Technical Director who supports the lighting department, helped me to set up the cameras in my scenes and the Houdini RenderMan network in order to render my resulting USD files.</p><p>Through the kindness and patience of all of my coworkers, I saw that mentorship was not just part of the internship program, but ingrained in the culture at Blue Sky. Mentorship came naturally to everyone because everyone was genuinely excited about the work and helping others get involved.</p><p>Going into my internship, I knew that I would learn a lot, but I didn’t realize I would experience a complete shift in the way I think about problems in computer graphics. In school, we are introduced to basic computer graphics concepts, such as loading small geometries into a Cornell box and rendering it with our own rendering engines. At Blue Sky, I had to learn to think bigger. Like, how am I going to parse the Moana island scene description, with 90 million unique quads and triangles?</p><p>How am I going to render it in our new pipeline when the final scene, with every tree, leaf, and piece of debris instanced, has 15 billion primitives and curves?</p><p>For these projects, it wasn’t enough just to apply what I was taught in school. I had to make sure my tools were efficient for use on an enormous production scene. Furthermore, these tools had to fit into a pipeline. In one sense, that not only meant thoroughly learning the industry standard software but also learning how to create plugins using the applicable APIs and frameworks. In another sense, that meant communicating effectively with artists to create user-friendly interfaces that fit their department’s needs and working collaboratively with other developers when creating larger projects and APIs.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/367/1*bLPvrSU_D1VwXD11YNWCUg.jpeg" /></figure><p>At the end of my summer, leaving Blue Sky was bittersweet. It was the end of the best internship I ever had, and I was sad to say goodbye to the amazing people I had met. However, I am going back to school full of excitement and with a much stronger sense of how I want grow as an engineer.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f0d9b68bca53" width="1" height="1" alt=""><hr><p><a href="https://medium.com/blue-sky-tech-blog/my-summer-at-blue-sky-studios-f0d9b68bca53">My Summer at Blue Sky Studios</a> was originally published in <a href="https://medium.com/blue-sky-tech-blog">Blue Sky Tech Blog</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[ChopRig System]]></title>
            <link>https://medium.com/blue-sky-tech-blog/choprig-system-b11d4c1e252c?source=rss----1d75ee699393---4</link>
            <guid isPermaLink="false">https://medium.com/p/b11d4c1e252c</guid>
            <category><![CDATA[engineering]]></category>
            <dc:creator><![CDATA[Daniel S. Lima]]></dc:creator>
            <pubDate>Fri, 10 Aug 2018 19:22:51 GMT</pubDate>
            <atom:updated>2018-08-11T14:04:58.297Z</atom:updated>
            <content:encoded><![CDATA[<p>The process of converting our current character rigs into a multi-threaded solution was one of the most significant challenges that Blue Sky Studios has had to face in recent years. Our goal was to find a solution to deliver our current rigs at a minimum evaluation speed of 24 fps. This solution also needed to be accomplished without compromising the actual rig mechanics or deformation quality of our assets. In the end, the optimization was designed to not hamper the standard rigging workflow or any other department’s standard pipeline processes.</p><p>Our goal was to update our rigging system in Maya® for parallel rig valuation and to maximize the multi-core capabilities of our current desktop architecture. Even though many of the deformers used in our characters were already internally multi-threaded, rigs did not meet our performance targets. This indicated to us that we needed to take a higher level approach to solve the problem.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/468/1*nfvsynUhHURY0TR2k6rGLg.png" /><figcaption>ChopRig Pipeline Process. It represents the average character’s performance in FPS Before and After the usage of the chopRig. It also shows the average independent deformer stacks on each chopped piece.</figcaption></figure><h3><strong>The Solution</strong></h3><p>The solution came with the creation of our ChopRig system, which breaks up the work in the rig so more tasks can be scheduled in parallel by the evaluation manager in Maya®. Instead of handing the entire geometry and its deformer stack to the scheduler all at once, we pre-separate the main geometry of the character, transferring the necessary portion of each deformer to each chopped piece. The final deformation of the pieces drove a combined mesh, using our proprietary “SubDeform” plugin, which was designed to be a lightweight evaluation. Doing this allows the scheduler to play a more significant role in load balancing all evaluation tasks across all cores in the machine. The gains were profound, giving us the interactive performance we desired.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*SLuNz4WZegMcd6wDt_GazQ.jpeg" /><figcaption>A. The original deformer stack performance as is — B. Multiple independent geometries with its own independent deformer stacks being evaluated in parallel — C. The original body geometry driven by multiple ones with its own independent deformer stack using our proprietary “SubDeform“ plugin. Each color represents a geometry with an independent deformer stack.</figcaption></figure><p>The ChopRig system uses a simple external data format, called DataCut, which is created by the rigger and consists of a pre-selection of edge loops. These edge loops represent where chops should occur in the character geometry. The chop lines can be placed anywhere in character, allowing us to configure the cuts in any way for different performance needs.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/927/1*oeo7blsZQI1MNY_gX6k3jA.jpeg" /><figcaption>DataCut set to chop the character’s geometry in half. This configuration will allow the computation of the left and right side in parallel.</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/637/1*s7x_dnXCmRbKZild2GoIwA.png" /><figcaption>This image shows an example of a deformer’s weight map painted only at the region of the character’s face. This way tells the ChopRig system to automatically transfer this particular deformer only to the respective points that belong to the proper chopped geometry, in this case, the chopHead geometry.</figcaption></figure><h3>How it Works</h3><p>After the rig is shipped to production, the ChopRig automatically splits the geometry using the DataCut, previously created by the Rigger. Then it transfers deformer nodes to each piece.</p><p>During the transfer, it scans the blendShape deltas and weight map influence of each character’s original deformer on each vertex and then only transfers what is relevant to the designated chopped geometry piece.</p><p>At the end of the ChopRig process, the system collects every chopped piece and uses these meshes to drive a copy of the original character’s mesh. This way we keep the final character topology consistent and entirely compatible with what Materials and Fur department have in hands.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*OGJG0fKSca-7TIKMRCwZVw.png" /><figcaption>Different chop configuration. Each color represents a geometry with an independent deformer stack.</figcaption></figure><h3>Conclusion</h3><p>The ChopRig process allowed us to meet a performance target of<br>evaluating character rigs for animation at interactive speeds above<br>24 fps. This solution has proven flexible and easily applied to all<br>kinds of character types. Our solution did not require a re-write of<br>our rigging system to accomplish our goals, and we were able to<br>test and deploy this new system during our character development<br>schedule. To the downstream departments our process was seam-<br>less, and fit right into the pipeline. In addition to achieving real-time<br>performance with our rigs, the ChopRig technology allowed the<br>animation department to develop a new set of workflows for shot<br>animation and asset visualization</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b11d4c1e252c" width="1" height="1" alt=""><hr><p><a href="https://medium.com/blue-sky-tech-blog/choprig-system-b11d4c1e252c">ChopRig System</a> was originally published in <a href="https://medium.com/blue-sky-tech-blog">Blue Sky Tech Blog</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>