LookdevTools
Installation
Tools
    Maya Surfacing Projects
        Hierarchical Structure
        Export
        Instances
        Substance Painter Udims
    Maya Surfacing Viewport
    txmake
    Material Mapping
        Texture Import
    Katana Surfacing Projects
Macros Gizmos and Templates
    Studio Lighting
    Katana
        Asset Turntable Template
        Material Lookdev
        Render Layers
        TextureSet Loader
        Texture Locatization
        Interactive Filters
        Grey Shaders Overrides
    Nuke
        AOV correct
        Lightgroups correct
        Lightgroups ContactSheet
    Gaffer
        ShaderView
Writing tools
    Example plugin
Road Map
    v0.1
    What's next
Credits

A tool set for maya, katana, gaffer, and nuke for surfacing and look development.
It aims to be the missing glue between maya (uv prepping and organizing), mari/painter, and maya/katana/gaffer rendering, covering most of the repeatitive tasks, letting you focus on the surfacing.
Based on my own tool box used for lookdev.

The rendering tools in Maya and Katana are based on Pixar Renderman, Gaffer tools based on Arnold.

A few environment variables are required for this tools.

/ldtenvset.sh

Coming soon

This tools allows you to:

• Organize maya meshes into different Surfacing Projects, and Surfacing Objects .
• Merge meshes for surfacing
• Export alembic files for surfacing
• Import the texture sets back to the Surfacing Projects and Surfacing Objects in Maya, Katana or Gaffer

Is a group of channels (textures) that describes a material, or the look of a material. For example, a metal textureSet would have channels for albedo, metalness, roughness, normal, etc

Is an individual texture (or several if using udim) that describe a single property of a material. For example: diffuseColor.

Is a group of meshes that will share a textureSet, for example: an armchair's leather parts, or the armchair's wooden parts.

Is a group of Surfacing Objects, for example: The armchair. This is usually what you will want to bring into your surfacing software, where you will have your Armchair leather and wooden parts as separated meshes. You can have as many Surfacing Projects as you want, to surface separately.

surfacing_root
    room 
        Floor
            wood
            rug
        walls
            wallFront
            wallLeft
            skirtings
    armChair
        leather
            back
            sit
            sides
        wood
            armrests
            legs
        blanket
            fabricSquare
            edgingFabric

When exporting, the tools merge the meshes inside a surfacing object. Following the example from above: It will merge all the Armchair's leather parts, as a single mesh called "leather".
The tool then reverts back to your original (non merged) scene. The armchair example from above exported.

Select the subdivision level to apply before exporting from the Surfacing Tool UI.

Usually this would not be a problem. However, if you are working on a heavy asset or scene (for ei the pixarCabin), you might find memory consumption spikes at export time due to subdivided meshes. If this is an issue, you can either export each surfacing_project individually, or optimize your scene:

• Check for high poly count objects in your scene
• Avoid adding Instances to Surfacing Objects, instead add the instance source.

As Mari is optimized for one single mesh, **Surfacing Objects** count inside a surfacing project is important.   
The amount of SurfacingObjects can impact your performance. The more SurfacingObjects you have inside a single  
surfacing project, the slower Mari will be.
It is not recommended using more than 8 **Surfacing Objects** per surfacing project for Mari.

When working with instanced meshes, as much as posible, add the instance source to the Surfacing Objects.
Notice in this set maya viewport -that was entirely built with instances- how only the instance sources are added to the Surfacing Objects, and not the set itself.

When using the Surfacing Project alembic file, and Substance Painter with udim:

• All meshes inside a Surfacing Object, must be contained inside a single udim
• Surfacing Objects should not have overlapping Uvs.

Assigns materials, or wireframe colors to Surfacing Projects or Surfacing Objects to visualize them in the Viewport.
Colors will match across applications.

There are plenty of txmake tools available.
What makes this tool handy is:

• multiprocessing: Run as many simultaneous txmakes as you want. This gives a performance boost of up to 9 times faster (as tested) when converting many textures at once.
• extra arguments list.
• search texture files recursively in a given folder.

Find and import textures into your maya scene. Search in folders is recursive.

Click on Search files in folder, and the tool will -for each texture file- load its surfacing project, surfacing_object, colorspace, textureset_element name as well as what shader_plug it should be connected in a PxrSurface shader, and group them together by udim.
Make any assignment changes in this excel like interface before importing.

{surfacing_project}_{surfacing_object}_{textureset_element}_{colorspace}.{UDim}.{extension}
For example:
   room_chair_baseColor_sRGB.1001.exr

206 Textures, from 6 Substance Painter textureSets imported to the Pixar cabin with a single click.

• If your file name has the {colorspace} token somewhere, the tools will create the file nodes with the correct colorspaces. OCIO partially supported, only the commonly used colorspaces.
  Valid colorspaces are:
  • sRGB
  • raw
  • linear
• The tool uses fuzzy string matching to give naming some flexibility to errors or differences, like capital letters, camel casing, or different spellings.

Creates collections and materials based on the Surfacing Projects and Surfacing Objects found in the scene graph.
It can also assign colors in the viewport, matching the colors of the maya Viewport materials and wireframe.

A node from the NodeGraph must be selected, this node will be used as the scene point where to cook and examine the scene graph locations.

Collections, viewport colors, and material assignments are based on attribute values at locations as in.

/root/world//*{attr("geometry.abcUser.myCustomAttribute") == value

The attributes used from this tools are standard alembic user properties:

abcUser.surfacing_project
abcUser.arbitrary.surfacing_object

It can also be used to create collections of all unique values for any given attribute.

A Studio ligthrig and a nuke template is available for Maya, Katana, and Gaffer.

WIP IMAGE

/plugis/gaffer/templates/studioLighting.gfr
/plugis/katana/templates/studioLighting.kat
/plugis/maya/templates/studioLighting.mb

Includes the pixar teapot, and a shaderball as generic assets for material look dev

Loads multiple texture files using tokens or keywords from a single node.

Using the <channel> keyword for each channel, and _MAPID_ for renderman.
It also accepts a manifold input (of any type), for tiling.

Metal_PaintedSteelBase_<channel>.tex   
woodenTable_<channel>._MAPID_.tex

Each channel (for ie: baseColor, or normal) can be added to the list.

Render layers additive creation with the usual parameters we all learned to love (or to live with!).

By setting the preffix, and a wildcard *, the settings will apply to all layers with that prefix.
Or *tree* and the settings will apply to any renderlayer with that prefix, that contains the word tree somewhere in the name.

All the render layers settings are stored in the scene graph as a render layer type location.
All settings (paths, CEL and collections) get flattened as a single CEL expressions.

Inspect your renderlayer setup CELs in the scene graph.

RenderLayer nodes work in conjuntion with a variable set name. Branch the layer down the graph when its more convinient for your scene.

In aggreate mode, you can add and remove objects (with CEL, collections, or paths) from an already set up render layer coming from above in the NodeGraph.

Note the /root/world/thisOtherLight in the aggregate mode and how it gets added to the original CEL expression in the render layer location attributes.

Opscript to search and replace paths in all PxrTexture nodes at .material.nodes

Point this Opscript to /root/world/geo//* if kfls are assigned to the objects.
Or to /materials//* if the materials are local to your scene.

Miscelaneous interactive filters for renderman 22

• Resolution half, third
• Quality presets
• Save n threads
• Scanning options
• Use it
• Integrators: occlusion, occlusion with albedo, direct lighting, and default
• Subdmeshes to poly (aka: ignore subdivisions)
• Grey shader override, and diffuseColor override for all materials

Replaces all your shaders with a 0.18 grey standard material.

This filter overrides only the diffuseColor with a 0.18 grey color.
Keeping all other materials features values, like specular, roughness, normals, diplacements, etc.

Select a nuke layer, and color correct it

Select a lightgroup layer from the preset menu, and mute/solo/color correct it

Creates a contact sheet of all the default lightgroups.
Two grid options available 1x5, and 1x12

Although you can select all the inputs, by default it expects ligthgroups named as in: lightgroup_a, lightgroup_b, lightgroup_c, and so on.

My Gaffer playground.

Creates Sets for each unique value for a given attribute.

Replaces the default ShaderBall scene node in the ShaderView, with the pixar Teapot or your own geometry.

The toolset is based on a plugin arquitecture.
See yapsy documentation for more info
http://yapsy.sourceforge.net/

ExamplePlugIn.plugin_layout QtWidget is what you need to populate in order to add and show an UI.

python/ldtplugins/example_plugin/__init__.py

from ldt import context

class ExamplePlugIn(IPlugin):
    '''Example plugin.'''
    name = "Example Plugin"

    plugin_layout = None

    def __init__ (self):
        dcc = context.dcc()
        # Replace 'Maya' with required dcc for plugin
        if dcc == 'Maya':
            logger.info('ExamplePlugIn loaded')
            # Add your dcc imports here
            self.build_ui()
        else:
            logger.warning(
                'ExamplePlugIn  not loaded, dcc libs not found')
            self.plugin_layout = QtWidgets.QWidget()
            self.label_ui = QtWidgets.QLabel(self.plugin_layout)
            self.label_ui.setText(
                'ExamplePlugIn\nPlugin not available in this application')

    
    def build_ui(self):
        '''Builds the ui for the plugin'''
        self.plugin_layout = QtWidgets.QWidget()
        plugin_layout = QtWidgets.QVBoxLayout()

        #UI Here

        # Set main layout
        self.plugin_layout.setLayout(plugin_layout)

python/ldtplugins/example_plugin.yapsy-plugin

[Core]
Name = Example plugin
Module = example_plugin

[Documentation]
Author = Ezequiel Mastrasso
Version = 1.0
Website = //ezequielm.com
Description = This is an example plugin configure, with UI entry points.

Project Board

Milestone Board

• Bridge the gap between all supported applications, while giving the minimum amount of tools to do so.
• Multiprocessing package to batch commmands.
• Minimum required Renderlayers, AOVs, viewport viz tools for maya and katana.
• Minimum required Nuke gizmos.
• Minumin required Mari gizmos for textureset library imports and tiling.
• Mari and Painter channel preset creation.
• Mari and Painter channel export presets.
• Maya and Katana turntable lightrigs for look dev
• Nuke comp templates for lookdev.

• Some code refactoring, and clean up to do
• Multiprocessing package
• Maya uv's viewport utilities
• Maya lighting, lightgroups, and aov tools
• Maya and Katana turntable lightrigs
• Nuke gizmos upgrade
• Katana texture set loader as a supertool
• Katana aov manager as a supertool

fuzzywuzzy   
lucidity   
yapsy   
Qt.py

Mathieu Maurel
shader ball

Elias Wick
Free checket pattern texture

Surfacing, lighting, and rendering done by Ezequiel Mastrasso.

Surfacing, lighting, and rendering done by Ezequiel Mastrasso.
This images are part of the original speed surfacing exercise that give birth to these tools.

However the look and style is based on the original winner of the pixar Kitchen challenge
Fabio Rossi Sciedlarczyk (scied)

Modeling, Surfacing, lighting, and rendering done by Ezequiel Mastrasso.

Official Swatch

HDRI Haven

thenounproject