nodes_slimbake.rman

Let's start with the definition of the new SBMakePtex pass and then look at it in detail below:

NodeType pass:command:SBMakePtex {
    reference Collection RequiredPassSettings
    reference NodeType {pass:render:SBRender}
    torattr phase {
        subtype selector
        range {
            "Once Per Job" {/Job/Preflight/Maps/SlimBake}
            "Every Frame" {/Job/Frames/Maps/SlimBake}
        }
        default {/Job/Frames/Maps/SlimBake}
    }
    # our job is to run ptxmake -filter none input output
    param ptxmake:depth {
        default half
    }
    param ptxmake:splat {
        default diffusion
    }
    param ptxmake:geom {
        default quad
    }
    param ptxmake:__inputfile {
        default {[passinfo this/0 filename]}
        uistate hidden
    }
    param ptxmake:__channel {
        default {$BAKECHAN}
        uistate hidden
    }
    param ptxmake:__outputfile {
        default {[passinfo this filename]}
        uistate hidden
    }
    torattr passCommand {
        default {[GetCmdPassCmdList \"\\${RMANTREE}/bin/ptxmake\"]}
    }
}

The first line indicates that we're defining a command pass, of class SBMakePtex. In the case of the SBRender pass, the word command is replaced with render, like "NodeType pass:render:SBRender".

The first line in the body of the pass definition, "reference Collection RequiredPassSettings", is just a shorthand way of including settings that might be common to several kinds of passes, so that we don't have to duplicate them, and so that it's easy to make general changes in one central place.

The next line, "reference NodeType {pass:render:SBRender}" indicates that our new pass must always be preceeded by an instance of an SBRenderPass, which we happen to know will produce the required point cloud.

Next, there are a series of pass settings. Each setting has a default value, and it is also possible to override any of the attributes from the definition of the setting, like the label, subtype, etc. The declarations of our new ptxmake settings are described in the next section.

The "phase" is a setting that is necessary for all passes, and indicates where in the "JobPhaseTree" the pass should reside. The JobPhaseTree defines general ordering of passes. For example, shadows can all occur together as a group (in parallel, if possible) that needs to preceed subsurface passes, etc. The phase setting has UI that allows the user to choose whether the pass should occur once per job or once per frame.

Next, we see a series of "param ptxmake:*" settings. The namespace "ptxmake" refers to the command that we'll execute, and is how we indicate that these params are all arguments to the ptxmake command. RfM will take care of turning these into an arg list to pass to the command.

Some of the param names begin with underscores, like "ptxmake:__inputfile", and "ptxmake:__outputfile". These are special keywords that indicate that these parameterss will be tacked on to the end of the arg list, without arg flags. The value "[passinfo this/0 filename]" is a Tcl expression that evaluates to the name of the output of the preceeding pass. And "[passinfo this filename]" evaluates to the name of the output of the current pass.

Finally, the passCommand is the setting that holds the actual ptxmake command. In this case, the value is a Tcl expression. This may seem a bit mysterious, but the idea is that by evaluating the expression we can produce an arbitrary list of ptxmake commands, depending on how many point cloud files were produced by the SBRender pass. The point clouds need to be converted one at a time. The Tcl command "GetCmdPassCmdList" is defined in RfMPassExpressions.tcl.

Since this pass description is used to define the interface that you will see in Maya, it is important to remember that these parameters are created as attributes on a Maya node. If you change this file and then re-open the Maya file you will find that the defaults and the parameters are the same as they were prior to editing the file, because they were burned into the Maya node. To see the new changes, be sure to delete the old node, and create a new pass class node.

decl_cmdparams.rman

decl_cmdparams.rman is an existing file that we edit to define the parameters referred to in the pass definiton. Since we are adding a ptxmake pass class, we need to declare the appropriate new parameters. These are added via Tcl commands that are evaluated to define the parameters.

The declaration is formatted like so:

Declare param <arg1> <arg2>

Where arg1 defines the type (string, float, int, or color) and the name, often with a namespace qualifier, such as ptxmake:<parameterName>. arg2 is a newline seperated list of commands:

label {label}
subtype {slider, selector, ifselector(imagefile),
    connection, file,
    masterswitch(don't know what this does),
    flag}
description {popup info for parameter}
range {start end increment}

The syntax for range above is for numbers; range can also be set for selectors:

range { label value
        label value}

or for files:

range {*.extension}

The example below shows how we handled the declaration for our test case.

# ptxmake controls ---------------------------------------------------------
Declare param {string ptxmake:__inputfile} {
    label "Input File"
    subtype file
}
Declare param {string ptxmake:newer} {
    label "Reuse"
    subtype flag
    description {
        If output file already exists, only perform ptxmake if input file
        is newer.
    }
}
Declare param {string ptxmake:depth} {
    label "Depth"
    subtype selector
    range {
        "byte" {byte}
        "short" {short}
        "half" {half}
        "float" {float}
    }
}
Declare param {string ptxmake:splat} {
    label "Splat"
    subtype selector
    range {
        "none" {none}
        "diffusion" {diffusion}
        "smooth" {smooth}
        "area" {area}
    }
}
Declare param {string ptxmake:geom} {
    label "Geom"
    subtype selector
    range {
        "quad" {quad}
        "tri"   {tri}
    }
}
Declare param {string ptxmake:__inputfile} {
    label "Point Cloud File"
}
Declare param {string ptxmake:__channel} {
    label "Channel"
}
Declare param {string ptxmake:__outputfile} {
    label "Output File"
}

RenderMan_for_Maya.ini

Your new pass type needs to be added to the "pass ref validity table" in your site-sepecific RenderMan_for_Maya.ini, to tell RfM which pass references are valid. For example, when rendering a deep shadow pass, you may have a shader with a parameter that references a subsurface scattering pass, but since the subsurface pass hasn't run yet, you don't want to allow the reference to the subsurface pass to be emitted into the shadow pass. Each entry in the table consists of one pass class followed by a list of pass classes in which that pass class is valid.

In the example below we have defined SBMakePtex as a valid pass type that exists downstream of SBRender and SBPtRender:

SBRender {SBRender SBPtRender SBMakePtCloud SBMakePtex SBMakeBrickmap}
SBPtRender {SBRender SBPtRender SBMakePtCloud SBMakePtex SBMakeBrickmap \
                Final BakeRender ReferenceRender}

SlimClientExpression.tcl

In our test case, since we are adding ptcToPtex to the bake node in Slim, we also need to register it as a possible bake pass class in SlimClientExpression.tcl. This is done like so:

ptcToPtex {
           set passclass SBMakePtex
}

This code serves to tell RfM what to do when ptcToPtex is passed to the pass generation code.