tk-config-codemultiroot Documentation

Welcome to another Tank sample config! This config is for demo purposes and goes through how to use Tank's multiroot storage option to split up the Tank code and configuration from the production data, since studios often want to keep them separate. It will also give an overview of what apps are available with Tank, as it matches what's in the default config.

The configuration contains a number of different pieces:

• A file system setup.
• A set of templates to identify key locations on disk.
• A set of preconfigured engines and apps which are chained together into a workflow.

Sometimes having the code and configuration next to the production data can confuse artists and/or encourage editing it when it may not be necessary. Many studios also like to keep all of their various tools in the same place, with Tank being another such tool. While there is a feature in the Tank and Shotgun roadmaps to allow for a more direct approach to specifying where the code and configuration go, using the multiroot storage option is a viable option until an improved setup can be implemented.

This sample config is meant to be minimal, and is focused on providing a demo and overview of Tank rather than being a fully featured file system. We strongly suggest that you get in touch with the Tank team if you need assistance when setting up file and folder structures with Tank, but hopefully examples like this will help clients get their desired structure!

File System Overview

This config handles Assets and Shots in Shotgun. It sets up two roots, one called "software," where the Tank code and configuration live, and another called "film," where all of the production data lives. The file system underneath the "film" root is otherwise the same as the Tank default config. The Shot structure looks like this:

To get this setup in place, first create Shotgun Storages of the "File Management" section of the Site Preferences. The "primary" root should still be named 'Tank,' as it is when using a single root. The other roots can be named as desired:

Next, create a roots.yml configuration file containing the Shotgun Storage info, but refer to the 'Tank' Storage in Shotgun as "primary" in the yml. Tank's engines and apps will try to make use of the configuration file where it can to save extra Shotgun queries as a means of helping with performance. When accessing Tank through Shotgun though, the Shotgun Storages will in turn be used. Here is the equivalent roots.yml for the above Shotgun Storages:

primary: 
    mac_path: /ryan/software
    linux_path: /ryan/software
    windows_path: S:\software

film: 
    mac_path: /ryan/film
    linux_path: /ryan/film
    windows_path: Z:\film

Then, place the roots.yml configuration file underneath the 'core' folder as indicated below. The schema folder should now contain subfolders that correspond to the Shotgun Storages as defined in roots.yml. In this case, all of the production data should go in the "film" root so it contains all of the schema configuration under it. The "primary" root only gets the code and configuration and doesn't have any schema folders, so it remains empty:

Finally, when configuring Project-based filters in the yml files for schema folders the $root name must be used instead of the $project token. In this case, sequences.yml should live under the "film" root and create folders for any Sequence in the Project, so its filter looks like this:

# shotgun filters to apply when getting the list of items
# this should be a list of dicts, each dict containing 
# three fields: path, relation and values
# (this is std shotgun API syntax)
# any values starting with $ are resolved into path objects
# DO NOT USE filters: [ { "path": "project", "relation": "is", "values": [ "$project" ] } ]
filters: [ { "path": "project", "relation": "is", "values": [ "$film" ] } ]

Applications and workflows

The config contains the following components:

• Maya, Nuke and Motionbuilder support.
• Shotgun Application Launchers.
• Publishing, Snapshotting and Version Control.
• A Nuke custom Write Node.
• Shotgun integration.
• A number of minor tools and utilities.

In addition to the apps above, you can easily install additional apps and engines once the config has been installed.

Setup and Configuration

To see all the various configuration parameters that you can set in order to customize the behaviour of this item, please head over to the settings page.

tk-config-codemultiroot Documentation. This was auto generated on 2013-02-28. Click here for Release Notes.