13. Integration with graphics software

Cerebro can be integrated with popular graphics software used in the CG industry: Autodesk Maya®, Autodesk 3ds Max, SideFX Houdini, MAXON Cinema 4D, Blender, Foundry Nuke®, Adobe Systems software.

The main advantages of the integration system for project task executors are as follows:

  • You can work with media files and their versions inside the graphics software without accessing the file system and considering filenames and paths.
  • You can omit the Cerebro program because you can accept tasks or materials and make reports inside your applications as well.

Therefore an executor will be able to reduce the time required for supplementary operations and to focus on completing tasks.

13.1. The integration system installation

The integration system is the Cerebro Tentaculo plugin which will be embedded into the respective graphics software after the installation.

There are two plugin installation options depending on the applications to integrate with:

13.1.1. Plugin installation for Autodesk Maya®, Autodesk 3ds Max, SideFX Houdini, MAXON Cinema 4D, Blender, Foundry Nuke®

The first step of the Cerebro Tentaculo installation is the distribution of the Cerebro Tentaculo Installer plugin among the Cerebro users.

To do this, download the archive with the plugin from the following link:
and unzip it.

13.1.1.1. Setting up the installer plugin

Prior to installing the plugin into Cerebro, you should set up the configuration file path_config.json included in the plugin. It is necessary for correct file loading with all dependencies in graphics software you use. It will also establish a correspondence between the task structure in Cerebro projects and the directory structure on the file server.

The configuration file in the JSON format is located in the root folder of the plugin and consists of the following sections:

  • the project_path list is the list of the projects paths;
  • the file_path list describes the directory structure inside projects.
  • the soft_folder variable is the directory used to store file versions; its value is to be changed depending on the graphics software which starts the plugin.
  • the processors list describes a set of additional Python scripts executed by the plugin at specified events.
  • the net_mode variable defines the mode of file operation for each application.
  • the trans_mode variable switches on the file path transliteration mode.

The configuration file must include project_path and file_path sections; other sections are added as may be necessary. The absence of a field in a section means that the corresponding key is set to the default value (empty string for the string fields).

The project_path section

The project_path must contain at least one item (by default) and consists of structures of the following type:

{
  "project_name": "",
  "task_activity": "",
  "paths": [
      "/s2/front/connector.files",
      "/Volumes/front/connector.files",
      "//s2/front/connector.files"
  ]
}

Each structure describes possible file paths to the project root directory and contains the following fields:

  • project_name is the project name in Cerebro; if the value is set to an empty string then the structure contains default values for the projects which are not described in other list structures;
  • task_activity is the name of the activity type provided that the file path to the root directory depends on this name; the empty value also means that the described file paths are applicable by default to tasks with any activity type.
  • paths (obligatory field) is a set of possible paths to the root directory, for example, for various operating systems.

The file_path section

The second section file_path of the configuration file must contain at least one item (by default) and consists of structures of the following type:

{
  "folder_path": "",
  "task_activity": "",
  "name": "$(url[3])",
  "name_editable": "False",
  "publish": "$(url[0])/$(url[1])/$(url[2])",
  "version": "$(url[0])/$(url[1])/$(url[2])/versions",
  "ver_prefix": "_v",
  "ver_padding": "3"
}

Each structure describes a set of subfolders and a filename pattern used for storing file versions and contains the following fields:

  • folder_path is the path in Cerebro until the beginning of the project fork (usually the project name or the project section name) or an empty string which means the structure with default values for any task/file;
  • task_activity is the name of the activity type provided that file names depend on it; the empty value also means that the described parameters can be applied by default to tasks with any activity type.
  • name (obligatory field) is the formatted file name;
  • name_editable (“False” by default) is a flag of the possibility to set a file name manually upon adding the file to a task.
  • publish (obligatory field) is the formatted path to the directory containing the main published version of a media file;
  • version (obligatory field) is the formatted path to the directory with file versions;
  • ver_prefix is the additional element in the name of a numbered version file;
  • ver_padding (“3” by default) is the number of digits in the version number.

If the values of the publish or version fields are not set then the plugin will not create the main or numbered version of the file correspondingly.

Note

The name field in the file_path section may contain an array of several values (for example, “name”: [“$(url[2])”, $(url[3]), $(task_name)”]). In this case a user can select a file name from several options in the dropdown menu when publishing the file.

Formatted paths and names can include the following variables:

  • $(url[0]), $(url[1]) … $(url[i]) is the name of a single item from the path to the selected task in Cerebro where i is the item’s nesting level starting from the project root. For example, $(url[0]) is the project name, $(url[1]) is the name of the first level subtask, etc.
  • $(soft_folder) is the directory for storing files. It is set in the variable of the soft_folder section (see below) and depends on the graphical host application;
  • $(task_name) is the name of the selected task in Cerebro, i.e. the last item of the $(url[i]) list;
  • $(task_path) is the path to the selected task in Cerebro. It consists of all $(url[i]) items including the last one;
  • $(task_parent_name) is the name of the parent task;
  • $(task_parent_path) is the path to the parent task in Cerebro.

You can use environment variables of the operating system provided that their names do not coincide with the variables listed above. They can be used in the same way: $(VARIABLE_NAME).

The soft_folder section

You can use the soft_folder variable to set the directory for storing versions, and the value may differ depending on the graphical application which started the plugin. The variable may be used in the formatted paths in other sections of the configuration file.

The soft_folder item structure:

{
  "maya": "",
  "nuke": "",
  "houdini": "",
  "blender": "",
  "cinema4d": "",
  "3dsmax": ""
}

The internal name of a supported graphical application (“maya”, “nuke”, “houdini”, “blender”, “cinema4d”, “3dsmax”) is a key in the set of paths, and the string with the directory name is the value.

The processors section

In the processors section, you can specify a set of additional Python scripts which will be executed by the plugin at specified events emerging during the work of the plugin.

The list of processed events:

  • opening a file – the name starts with “open”;
  • creating a new file in the task – the name starts with “new”;
  • saving a version – the name starts with “version”;
  • publishing a report – the name starts with “publish”.

There are 3 call points of the function handler relative to the main function for each operation type:

  • before executing the main function – the name ends with “_pre”;
  • to replace the main function – the name ends with “_replace”;
  • after executing the main function – the name ends with “_post”.

The structure of the processors item (only file opening handlers are shown):

{
  "soft_name":
  {
    "open_pre":
    {
      "script_path": "path/to/script.py",
      "function": "open_pre"
    },
    "open_replace":
    {
      "script_path": "path/to/script.py",
      "function": "open_replace"
    },
    "open_post":
    {
      "script_path": "path/to/script.py",
      "function": "open_post"
    },

    ...

  }
}

The structure describes a set of additional scripts for one of supported graphical application and contains the following fields:

  • the soft_name variable is the internal name of a supported graphical application provided that a set of additional scripts is defined for this application.
  • an array of elements describing handlers where each element contains two fields:
    • script_path – the full path to a Python script (handler);
    • function – the function name inside the script.

Handler parameters

Handler functions from additional scripts must correspond with certain call agreements namely:

  • accept two parameters, Python dictionaries (see the details below), as arguments;
  • return the second dictionary, probably the modified one.

The first argument is the same for all handlers and contains the following elements:

  • task_id – the ID of a task in Cerebro;
  • task_name – the name of the task;
  • task_parent_id – the ID of a parent task;
  • task_parent_path – the parent task path in Cerebro;
  • task_status_id – the ID of the current status of the task;
  • task_status_name – the name of the current status of the task;
  • task_activity_id – the ID of the activity type of the task;
  • task_activity_name – the name of the activity type of the task;
  • current_user_id – the current user ID;
  • current_user_name – the current user displayed name.

The second argument of the function may differ depending on the type of the processed event:

  • for all create and open a file events – a dictionary with the following elements:

    • original_file_path – the full path to the source file;
    • local_file_path – the full path to the working file.
  • for all save the version and publish the report events – a dictionary with the following structure:

    {
      "local_file_path": "",
      "version_file_path": "",
      "publish_file_path": "",
      "report":
      {
        "plain_text": "",
        "work_time": ""
      },
      "attachments":
      {
        "file_path": [ paths to file thumbnails ],
        ...
      },
      "links":
      {
        "file_path": [ paths to file thumbnails ],
        ...
      }
    }
    

    , where

    • local_file_path – the full path to the working file;
    • version_file_path – the full path to the version file to be published;
    • publish_file_path – the full path to the main file to be published (used only for report publishing events);
    • report – the data for a Cerebro report, it is comprised of two fields: the report text and the work time in minutes;
    • attachments – a set of files attached to the report, it contains the list of the file paths;
    • links – a set of files attached to the report with a link, it contains the list of the file paths.

The net_mode section

You can use the net_mode variable to set the mode of file operations. It can accept various values depending on the graphics software starting the plugin.

The net_mode item structure:

{
  "maya": "",
  "nuke": "",
  "houdini": "",
  "blender": "",
  "cinema4d": "",
  "3dsmax": ""
}

Possible values of the variable for an application:

  • local is used for work in the internal network of a company; prior to accessing files they are copied to the local directory on the workstation;
  • network (the default value) is used for work in the internal network of a company; files are accessed directly in the network catalogue without copying to a local directory;
  • remote is used for remote work; files are accessed using HTTP and sent to the storage using the Cargador.

The trans_mode section

You can use the trans_mode variable to switch on the transliteration of file paths corresponding to the Cerebro tasks. It can accept various values depending on the graphical application starting the plugin.

The trans_mode item structure:

{
  "maya": "",
  "nuke": "",
  "houdini": "",
  "blender": "",
  "cinema4d": "",
  "3dsmax": ""
}

Possible values: False (by default), True.

If the transliteration mode is switched on, all Cyrillic letters in the file paths will be converted automatically into Latin letters and white spaces will be converted into underscore symbols (“_”). For example, the file path /Project 01/Моделирование will be converted into /Project_01/Modelirovanie.

13.1.1.2. A configuration file example

Let us dwell on a configuration file example.

{
    "project_path": [
        {
            "project_name": "",
            "task_activity": "",
            "paths": [
                "/s2/front/connector.files",
                "/Volumes/front/connector.files",
                "//s2/front/connector.files"
            ]
        }
    ],
    "file_path": [
        {
            "folder_path": "",
            "task_activity": "",
            "name": "$(task_name)",
            "publish": "$(url[0])/$(url[1])/$(url[2])",
            "version": "$(url[0])/$(url[1])/$(url[2])/versions",
            "ver_prefix": "_v",
            "ver_padding": "3"
        },
        {
            "folder_path": "/$(url[0])/Environment",
            "task_activity": "texturing",
            "name": "$(task_name)",
            "publish": "$(url[0])/$(url[1])/$(url[2])/$(soft_folder)/",
            "version": "$(url[0])/$(url[1])/$(url[2])/$(soft_folder)/versions",
            "ver_prefix": "_v",
            "ver_padding": "2"
        }
    ],
    "soft_folder":
    {
        "maya": "3D",
        "nuke": "Compose",
        "houdini": "3D",
        "blender": "3D",
        "cinema4d": "3D",
        "3dsmax": "3D"
    },
    "processors":
    {
        "maya":
        {
            "new_pre":
            {
                "script_path": "//s2/front/testwnd.py",
                "function": "new_pre"
            },
            "new_post":
            {
                "script_path": "//s2/front/testwnd.py",
                "function": "new_post"
            }
        }
    }
}

In this example, the project_path section contains one structure with an empty project name and activity type, i.e. default values for all projects/tasks. Inside the structure, there are three possible paths to the root directory with the project files. It is the path to the public folder for Linux, Mac OS X and Windows operating systems correspondingly.

The file_path section contains two structures. The first one describes default paths and names for any projects and project sections. The second one is used only for texturing tasks in any project of the “Environment” subsection.

The second structure also enables the $(soft_folder) variable. Its values are described in the next section of the configuration file.

For example, according to the structure in the project_path and the first structure of the file_path section the Cerebro task with URL cerebro:/Cartoon_1/Ep_01/Sc_01/modeling will have the following location of Autodesk Maya® files in the Windows operating system:

  • the main version of the file:
    //s2/front/connector.files/Cartoon_1/Ep_01/Sc_01/modeling.ma
  • numbered versions (number 1, 2, 3, …) as follows:
    //s2/front/connector.files/Cartoon_1/Ep_01/Sc_01/versions/modeling_v001. ma

And according to the structure in the project_path and the second structure in the file_path section the task with URL cerebro:/Cartoon_2/Environment/Johns House/texturing will be located as follows:

  • the main version of the file:
    //s2/front/connector.files/Cartoon_2/Environment/Johns House/3D/texturing. ma
  • numbered versions as follows:
    //s2/front/connector.files/Cartoon_2/Environment/Johns House/3D/versions/texturing_v01.ma

The second example of the task includes the 3D subdirectory which is added for the Autodesk Maya® program in accordance with the soft_folder structure, and another digital capacity is used for the version number.

The processors section describes two event handlers for the Autodesk Maya® host application:

  • “new_pre” means triggering before creating a new file, the new_pre function from the public script //s2/front/testwnd.py is called;
  • “new_post” means triggering after creating a new file, the new_post function from the public script //s2/front/testwnd.py is called.

13.1.1.3. Installer plugin distribution

The configured plugin must be uploaded to the distribution system under the Cerebro administrator account. This can be done in the Cerebro administrator panel of the Universe section on the Plugins tab. For more details see the section “Universes”.

Since Cerebro Tentaculo works in the company’s local network, you must register it in Cerebro as a network plugin and locate it in the public folder of the file server. No additional installation on working stations is needed, the plugin will be loaded automatically for all machines having access to the network location of the plugin.

Note

Please note that for the heterogeneous OS environment (user machines have different OS) you need to ensure accessibility of the network path to the plugin folder for all the operating systems used by the affected machines. Therefore you may need to do the corresponding path substitution for various OS (see the section “Directory Mapping”).

13.1.1.4. Installation at the working station

The second step of the integration system installation is implemented after the Cerebro Tentaculo Installer plugin activation on working stations. The plugin will automatically detect supported programs, therefore corresponding graphics software must be installed prior to the plugin launch.

To perform the installation, launch Cerebro and activate Tentaculo/Install in the main menu (this menu section appears only in case of the successful loading of the Cerebro Tentaculo Installer plugin). You will see the installer window:

_images/cerebro_integ_install.png

In case of the successful installation, the Cerebro section will appear in the main menu of the corresponding graphics software.

13.1.2. Installation of the plugin for Adobe Systems products

In this case, Cerebro Tentaculo is installed using the Adobe Exchange system. You can find the Cerebro Tentaculo extension on the Adobe Exchange website or use this direct link: https://www.adobeexchange.com/creativecloud.details.100337.html

_images/cerebro_integ_exchange.png

To install the extension, in the upper right corner of the Cerebro Tentaculo extension web page, click Free and follow the instructions.

Note

According to the installation guide from the Adobe Exchange website, if you were unable to install the extension using the Adobe Creative Cloud application, you can use third-party extension managers for Adobe Systems products, for example, Anastasiy’s Extension Manager (for details follow the link to see the instructions: https://www.adobeexchange.com/creativecloud/install-instructions.html).

To use the installed extension, launch the corresponding graphical application and activate Window/Extensions/Cerebro in the main menu. The Cerebro authorisation window will appear in case of success.

_images/cerebro_integ_adoblogin.png

13.2. The integration system usage

After installation, the integration system functions are represented as the Cerebro integrated menu section inside the graphics software (in Adobe Systems products, it is located in the Window/Extensions/Cerebro section). Menu items and user interface elements are the same for all supported software.

_images/cerebro_integ_menu.png

To access the Cerebro system, the credentials saved at the previous session are used. If there are no saved credentials or you have finished your previous session using the Cerebro/Logout command then you will have to enter account settings manually when first accessed Cerebro Tentaculo functions.

_images/cerebro_integ_login.png

In the login window, you can enter the user’s login and password, as well as tick the option to remember your credentials and log in automatically. The window is similar to the Cerebro login window (see the section “Login and user profile”).

13.2.1. Working with a list of tasks

The user’s personal list of tasks, which is similar to the Allocated list in the Cerebro client module (see the section “To Do list”), is supposed to be the main tool of the Cerebro Tentaculo user.

When a task is assigned to you it appears in your Todo List. As soon as the task’s status is set to ready to start you can start working on it.

You can open up this list by clicking Cerebro/Todo List in the menu.

_images/cerebro_integ_todo.png

In the pop-up window, on the left side, you will see the list of tasks assigned to the user and choose the sorting mode from the dropdown menu at the top of the window.

On the right side, the content of the selected task is displayed. The heading displays general attributes of the task: the name, path inside the project, status, and deadline.

The Files list shows the list of versions published in this task sorted by the publication date in the descending order.

The following icons are used to highlight the list items:

  • the main published version of the file (the icon with the Latin letter “P”) is the current variant of the file processed in the graphical application; it usually coincides with the latest published version.
  • the local version of the file (the icon with the image of a computer) is the version stored locally on the computer’s hard drive and processed in the graphical application. It has not been published in Cerebro yet and can be displayed only on the workstation where it was created.

Note

In fact, a Cerebro task does not display the full list of files attached to the task. It shows only the list of files filtered by extensions supported by the graphical application running the Cerebro Tentaculo plugin (for example, for Autodesk Maya® only files with .ma extension will be displayed).

Messages from the task’s forum are displayed as a text feed on the right of the Files list.

Note

Access to operations on a task or files may be limited if another executor has already accepted the task; then the lock icon will be displayed in the task’s heading.

You can accept a task by clicking a button under the list of versions.

_images/cerebro_integ_taskactions.png

You have the following options:

  • If no file is selected in the list of versions, then the button under the list is labelled Start working on this task. Clicking the button will launch an automatic selection of a version which will be loaded into the graphical application. This will be the main version or the local one (depending on the date of creation). If the list of versions is empty, a new file will be created.

  • If any file is selected in the list of versions (not necessarily the latest version), then the button under the list is labelled Start working on this file. Clicking the button will load the selected version into the application for further editing.

  • Regardless of availability and selection of versions in the list, you can use commands called by the “+” button under the list:

    • New File – create a new file and start working on it;
    • Import from Preceeding Task – load the version from the task of the previous stage, i.e. find the predecessor task and load the main published version as the source file to work on using Cerebro links (see the section “Linking tasks”).

If you accept the task its status will be set to in progress, and the report will be published together with the graphical file in the task’s forum in Cerebro. Then you can close the list of tasks window and proceed with working on the file.

Other commands applicable to the list items are available in the context menu which appears upon the right-click on a file.

_images/cerebro_integ_fileactions.png
  • Start working on this file is used to start working on the selected file, i.e. it is the same action as clicking the Start working on this file button when this file is selected in the list.
  • Open without Starting the Task is used to open the selected file in the graphical application without starting the task.
  • Link is used to insert objects from the selected file into the current scene using a link. Changes in the linked file will be displayed in the general scene as well.
  • Embed is used to insert objects from the selected file into the current scene. Further changes in this file will not affect the general scene.
  • Show in Explorer is used to show the selected file in the folder on the hard drive.
  • Copy Local Path to Clipboard is used to copy the local path of the selected file to the clipboard.

Note

The actions similar to the Link and Embed context menu commands can also be performed in the project browser in the Link/Embed mode (see the section “The browser in the Link/Embed mode”).

In the bottom right corner of the list of tasks window, there are two buttons: Save as New Version and Publish. Both buttons prepare a report and send the current file version to Cerebro. The only difference is that the first button only adds a new version to the list of files, whereas the second button publishes the file as the main version of the task in addition. For more details on preparing a report see the section “Publishing a report”.

13.2.2. Working with the project browser

Sometimes you may need to access some parts of a project beyond the list of the assigned tasks, for example, if these parts contain files necessary for your work. For these aims, there is the second tab in the list of tasks window containing the project browser.

_images/cerebro_integ_browser.png

In this window, on the left side, the project tree is displayed which is similar to the one in the Cerebro navigator (see the section “Navigator”). Using the tree, you can access any available project/task. Selected tasks and the scope of functions upon a task are displayed in the way similar to the Todo list window except for the Link/Embed mode (see the section “The browser in the Link/Embed mode”).

Note

If you start working on a file from one task, you can publish it in another task after processing. Thus, for example, you can take the result of another executor’s work as the source file for your task.

Above the project tree, there is a search field to look for a task by a keyword. If you start entering the task name, the list of tasks will be filtered by the presence of the entered substring in the task names.

13.2.3. Publishing a report

Once work on the graphical file is complete, you can make a report and publish the current version. By default, the message will be published in the task you have accepted.

Every time you send the current file from the graphics software to Cerebro, the report creation window is displayed.

_images/cerebro_integ_report.png

Possible options:

  • The main menu Cerebro/Save as version or the Save as New Version button in the list of tasks (browser) – a new version is added to the list of files, the main version remains unchanged. In this case, the button in the report window is labelled Report, not Publish.
  • The main menu Cerebro/Publish or the Publish button in the list of tasks (browser) – a new version is added to the list of files and the main version is updated.

In both cases mentioned above, if you clicked inside the Todo list window, then the file will be sent to the current task in the window. If you clicked inside the menu, then the file will be sent to the source task.

At the top of the report window, you can see the name and Cerebro path to the task where you will send the message, as well as a button to choose another task (using the project browser).

On the left side of the window, you can find the thumbnail corresponding to the file you send and the version name.

Note

Tentaculo for Adobe Systems products slightly differs in this respect: you can not choose a task in the report window, however, you can change the filename. Also, the file will be published in Cerebro as an attachment, not a link.

On the right side of the window, you can find tools for writing the text of the report, selecting a new status for the task and setting the hours worked. These parameters, as well as the link to the file of the version, define the report which will be published in the Cerebro forum (see the section “Forum”).