User Guide Cancel

compnode | Substance 3D Automation ToolKit

Search
Substance 3D Automation Toolkit

Substance 3D Automation Toolkit

Open app
  1. Substance 3D home
  2. Home
  3. Command Line Tools
    1. Command Line overview
    2. sbsbaker
      1. sbsbaker overview
      2. sbsbaker command line options
      3. sbsbaker Example Command Lines
    3. sbscooker
      1. sbscooker overview
      2. sbscooker command line options
      3. sbscooker pattern variables
    4. sbsmtools
      1. sbsmtools overview
      2. sbsmtools command line options
    5. sbsmutator
      1. sbsmutator overview
      2. sbsmutator command line options
      3. sbsmutator Example Command Lines
    6. sbsrender
      1. sbsrender overview
      2. sbsrender base parameters and pattern variables
      3. sbsrender command line options
      4. sbsrender example command lines
    7. sbsupdater
      1. sbsupdater overview
      2. sbsupdater command line options
  4. Pysbs - Python API
    1. Pysbs - Python API overview
    2. Getting started
    3. General topics
      1. Basic manipulation
      2. Substance creation
      3. Substances modification
      4. Dependencies management
      5. PySbs batchtools module
      6. metadata manipulation
      7. SAT demos
      8. Edit sbsar with SBSARManager
      9. Spot Colors
      10. Thumbnail creation with SAT
    4. Examples
      1. demohelloworld
      2. demos
      3. demos_batchtools
      4. script_update_with_sbsupdater
    5. API Content
      1. API Content overview
      2. Substance definitions
        1. Common interfaces
          1. basegraph
          2. package
          3. sbsarobject
          4. sbsobject
        2. compnode
          1. compnode overview
          2. common
          3. compimplementation
          4. paramgraph
        3. context projectmgr
        4. graph
          1. graph overview
          2. function
          3. inputparameters
          4. output
        5. mdl
          1. mdlannotation
          2. mdlcommon
          3. mdldictionaries
          4. mdlenum
          5. mdlgraph
          6. mdllibclasses
          7. mdlmanager
          8. mdlnode
          9. mdlnodeimpl
          10. mdloperand
          11. mdlsbsbridge
        6. modelgraphindex
          1. modelannotationnames
          2. modelgraph
          3. modelgraphgenerator
          4. modelgraphimplementation
          5. modelnodenames
          6. modeloperand
          7. modulegraphindex
          8. moduleannotation
          9. moduleconnection
          10. modulegraph
          11. modulegraphgenerator
          12. modulegraphimplementation
          13. modulegraphlibrary
          14. modulegraphregister
          15. modulenode
          16. modulenodeimplementation
          17. modulenodeinstance
          18. moduleoperand
          19. moduleoutputbridging
          20. moduleparaminput
        7. params
          1. params overview
          2. dynamicvalue
          3. paramnode
        8. projectmgrdoc
        9. sbsarchive
          1. sbsarchive overview
          2. sbsarenum
          3. sbsargraph
          4. sbsargui
          5. sbsarguiwidgets
          6. sbsarmanager
        10. sbscommon
          1. connections
          2. gui
          3. nodes
          4. values
        11. sbspreset
        12. sbsproject
        13. substance
          1. substance overview
          2. content
          3. resource
      3. Libraries
        1. sbsenum
        2. sbslibrary
          1. sbslibrary overview
          2. sbsdictionaries
          3. sbsfilters
          4. sbsfunctions
          5. sbsfxmapnodes
          6. sbslibclasses
          7. sbswidgets
        3. sbsbakerslibrary
          1. sbsbakerslibrary overview
          2. sbsbakersdef
          3. sbsbakersdefaultprops
          4. sbsbakersdictionaries
          5. sbsbakersenum
          6. sbsbakingconverter
          7. sbsbakingconverterparam
          8. sbsbakingparameters
          9. sbsdialogstate
          10. sbsscenedata
        4. Helpers
          1. sbscleaner
          2. sbsexporter
          3. sbsgenerator
          4. sbsparser
          5. sbswriter
          6. qtclasses
            1. qtclasses overview
            2. qtvariantreader
            3. qtvariantwriter
          7. psdparser
          8. sbsimpactmanager
          9. batchtools
          10. autograph
            1. ag_functions
            2. ag_layout
            3. ag_types
          11. info_mesh_parser
          12. sbsbaker_info_handlers
          13. sbsrender_render_handlers
          14. output_handlers
          15. spotcolorinfo_handler
          16. thumbnail
          17. batchtools overview
        5. Execution context
          1. context
          2. functions
        6. API Change log
  5. Samples
    1. Samples overview
    2. Texturing Template Demo
    3. Batch Tools Demo
    4. Variations
    5. Texture Mat
    6. Pixel Processor Ray tracer
  6. Setup and Getting Started
    1. Setup and Getting Started overview
    2. Compatibility
    3. Frequently asked Questions
    4. Known issues
    5. SAT Cookbook
    6. Use Pysbs in different python interpreter (maya, sd, blender...)
  7. Integrations
    1. Substance Maya toolset
      1. Substance Maya Toolset overview
      2. Installing
      3. Launching
      4. Baking
        1. Baking overview
        2. Export parameters
        3. Baker parameters
        4. Mesh setup
        5. Using a template
      5. Changelog
  8. Changelog overview

compnode

Content included in compnode module:

Module compnode aims to define SBSObjects that are relative to a compositing Node, mostly SBSCompNode, SBSCompImplementation and SBSCompOutput.

 class compnode.compnode.SBSCompNode(aGUIName=None, aUID='', aDisabled=None, aGUILayout=None, aOptions=None, aCompOutputs=None, aConnections=None, aCompImplementation=None, aInputValues=None)

Bases: pysbs.sbscommon.nodes.SBSNode

Class that contains information on a compositing node as defined in a .sbs file

Members:
  • mGUIName (str, optional): name of the node.
  • mUID (str): node unique identifier in the /compNodes/ context.
  • mDisabled (str, optional): this node is disabled (“1” / None).
  • mGUILayout (SBSGUILayout): GUI position/options
  • mOptions (list of SBSOption): options list.
  • mCompOutputs (list of SBSCompOutput, optional): outputs list.
  • mConnections (list of SBSConnection, optional): input connections list.
  • mCompImplementation (SBSCompImplementation): implementation of the compositing node.
  • mInputValues (list of SBSCompInputValue: Input values for the node 
 applyPreset(aPresetLabel)

Apply the given preset on node’s parameters. If the the node doesn’t implement a SBSCompInstance an error will be raised. If aPresetLabel doesn’t exist an error will be raised.

Parameters:aPresetLabel – an identifier or a label of the preset to apply.
Returns: 
 applyPresetFromFile(aPresetFilePath, aPresetLabel, aContext=None)

Apply the given preset from a file on node’s parameters. If the the node doesn’t implement a SBSCompInstance an error will be raised. If aPresetLabel doesn’t exist an error will be raised.

Parameters:aPresetLabel – an identifier or a label of the preset to apply.
Returns: 
 classify(aOther, aParentContainer = None)

Use the definition of the two nodes to classify them, and their GUI position if they have the same definition.

To classify the different kind of CompImplementation, this order is specify:

Filter < Instance < Input < Output.

For the Filter, the filter identifier is used to classify them.

For the Instance, the lexicographic order is used on the instance path.

At a final option, the GUI position is used, and in this case, mostLeft < mostRight and then mostUp < mostDown.

Parameters:
  • aOther (SBSCompNode) – The node to compare to.
  • aParentContainer (SBSGraph, optional) – The graph containing the nodes to classify
Returns:

1 if itself is considered greater than the other node, -1 for the opposite. 0 in case of equality.

 
 computeUniqueInputValueIdentifier(aIdentifier)

Check if the given identifier is already used in the node inputs and generate a unique identifier if necessary

Returns:A unique identifier 
 createInputValue(aIdentifier, aType)

Create a new Input Value attached to the node. SBSCompInputValue

Parameters:
  • aIdentifier (str) – an unique identifier name, if aIdentifier already exist in the current input values identifiers a suffix will be added. The identifier must start by # it will added if it’s not present.
  • aType (int) – the input value type (only boolean and numerical) presents in InputValueTypeEnum 
 createIterationOnPattern(aParameter, aNbIteration, aNodeUIDs, aNodeUIDs_NextPatternInput = None, aGUIOffset = None)

Allows to create an iteration in the function defining the value of the given parameter.

Duplicate nbIteration times the given node, to create this kind of connection:

Pattern -> Pattern_1 -> Pattern_2 -> … -> Pattern_N

Parameters:
  • aParameter (CompNodeParamEnum or str) – Parameter
  • aNbIteration (positive integer) – number of time the pattern must be duplicated
  • aNodeUIDs (list of str) – list of node’s UID that constitute the pattern to duplicate
  • aNodeUIDs_NextPattern (list of str, optional) – list of node’s UID that correspond to the inputs of the next pattern, which must be connected to the given pattern. Default to []
  • aGUIOffset (list of 2 float, optional) – pattern position offset. Default to [150, 0]
Returns:

The list of params.SBSParamNode created
Raise:

api_exceptions.SBSImpossibleActionError

 
 equals(other)

Check if this SBSObject is equivalent to the other SBSObject. Some members may be excluded from this check, the UIDs or GUILayout for instance.

Parameters:other (SBSObject) – The SBSObject to compare to
Returns:True if the two SBSObject are similar according to their definition. 
 getCompFilter()
Returns:the SBSCompFilter object if this node is a compositing filter, None otherwise. 
 getCompImplementation(self)

Return the appropriate comp implementation depending on the compositing node kind

Returns:A SBSCompImplWithParams or a SBSCompOutputBridge 
 getCompInputBridge()
Returns:the SBSCompInputBridge object if this node is an input bridge, None otherwise. 
 getCompInstance()
Returns:the SBSCompInstance object if this node is a compositing graph instance, None otherwise. 
 getCompOutput(aCompOutputUID = None)

Get the output with the given uid. If aCompOutputUID is None, get the type of the first output, if it exists

Parameters:aCompOutputUID (str, optional) – UID of the output. If None, the first output is returned
Returns:a SBSCompOutput object if found, None otherwise 
 getCompOutputBridge()
Returns:the SBSCompOutputBridge object if this node is an output bridge, None otherwise. 
 getCompOutputFromBridge(aOutputBridge)

Get the output corresponding to the given bridge identifier. This can work only on an instance node.

Parameters:aOutputBridge (str) – identifier of the output bridge.
Returns:a SBSCompOutput object if found, None otherwise 
 getCompOutputFromIdentifier(aOutputIdentifier = None)

Get the output with the given identifier. If aOutputIdentifier is None, get the first output, if it exists

Parameters:aOutputIdentifier (str, optional) – identifier of the output. If None, the first output is returned
Returns:A SBSCompOutput object if found, None otherwise 
 getCompOutputIdentifier(aCompOutputUID = None)

Get the identifier of the output with the given uid. If aCompOutputUID is None, get the identifier of the first output, if it exists

Parameters:aCompOutputUID (str, optional) – UID of the output. If None, the identifier of the first output is returned
Returns:The identifier of the given output if found, None otherwise 
 getCompOutputType(aCompOutputUID = None)

Get the type of the output with the given uid. If aCompOutputUID is None, get the type of the first output, if it exists

Parameters:aCompOutputUID (str, optional) – UID of the output. If None, the type of the first output is returned
Returns:The type of the given output if found as a ParamTypeEnum, None otherwise 
 getConnectedNodesUID()

Get the UIDs of the nodes connected to this node.

Returns:The UIDs as a list of string 
 getConnectionOnPin(aPinIdentifier)

Get the connection defined on the given input.

Parameters:aPinIdentifier (str) – identifier of the input pin (for SBSCompNode, SBSParamNode and MDLNode) or of the output pin(for SBSParamsGraphNode)
Returns:a SBSConnection object corresponding to the connection defined on the given pin. None otherwise 
 getConnections()

Get the connections defined on this node.

Returns:a list of SBSConnection 
 getConnectionsFromNode(aLeftNode)

Get all the connections coming from the given left node.

Parameters:aLeftNode (SBSNode or str) – The node to look for in the incoming connections of this node, as an object or a UID
Returns:a list of SBSConnection 
 getDefinedParameters()

Get the list of parameters defined on this node.

Returns:the list of SBSParameter specified on this node. 
 getDefinition()

Get the node definition (Inputs, Outputs, Parameters) accordingly to the compnode implementation

Returns:a CompNodeDef object if defined, None otherwise 
 getDisplayName()

Get the display name of this node

Returns:the display name as a string 
 getDynamicParameters()

Get the list of dynamic parameters defined on this node.

Returns:the list of SBSParameter specified on this node that have a dynamic function. 
 getFxMapGraph()

Get the SBSParamsGraph object which defines the FxMap graph

Returns:For a FxMap filter, returns the graph of this FxMap as a SBSParamsGraph, None otherwise. 
 getFxMapGraphNode(aUID)

For a FxMap filter, browse the graph of this FxMap and get the SBSParamsGraphNode with the given UID

Returns:A SBSParamsGraphNode object with the given UID if found, None otherwise. 
 getInputDefinition(self, aInputIdentifier=None)

Get the input definition corresponding to the given identifier.

Parameters:aInputIdentifier (InputEnum or str, optional) – The identifier to get. If let None, the primary input will be returned
Returns:the input definition as a CompNodeInput if found, None otherwise 
 getInputValue(aIdentifier)

return corresponding InputValue aIdentifier, SBSCompInputValue :param aIdentifier: identifier name must start by # it will added if it’s not present. :type aIdentifier: str :return:

 getOffsetPosition(aOffset = None)

Compute the position of this node offset by the given offset

Parameters:aOffset (list of 2 float, optional) – the offset to apply to the node’s current position. Default to [0,0]
Returns:the offset position 
 getParameterValue(aParameter)

Find a parameter with the given name in the appropriate comp node implementation, and return its value.

Parameters:aParameter (CompNodeParamEnum or str) – Parameter identifier
Returns:The parameter value if found, None otherwise 
 getPixProcFunction()

Get the SBSDynamicValue object which corresponds to the Pixel Processor Function. Create the dynamic value if it is None.

Parameters:createIfEmtpy (bool) – If True it creates an empty pixel processor graph if there is none attached already If False and no pixel processor exists it will return None
Returns:For a PixelProcessor filter, returns the function of this PixelProcessor, None otherwise. 
 getPosition()

Get the position of this node in the graph GUI.

Returns:a list of 3 float 
 getRect()

Return the rectangle of this node.

Returns:The rectangle as a Rect 
 getUidIsUsed(aUID)

Parse the CompOutputs list to find a SBSCompNode with the given uid

Parameters:aUID (str) – UID to check
Returns:True if this uid is already used, False otherwise 
 getValProcFunction(createIfEmtpy=True)

Get the SBSDynamicValue object which corresponds to the Value Processor Function. Create the dynamic value if it is None.

Parameters:createIfEmtpy (bool) – If True it creates an empty value processor graph if there is none attached already If False and no value processor exists it will return None
Returns:For a ValueProcessor filter, returns the function of this ValueProcessor, None otherwise. 
 hasAReferenceOnDependency(aDependency)

Check if this node directly references the given dependency. For instance if it instantiates a graph or a resource included in this dependency.

Parameters:aDependency (str or SBSDependency) – The dependency to look for (UID or object)
Returns:True if this node references this dependency, False otherwise 
 hasAReferenceOnInternalPath(aInternalPath)

Check if this node references the given internal path (pkg:///). For instance if it instantiates the graph or the resource pointed at the given path.

Parameters:aInternalPath (str) – The internal path to look for
Returns:True if this node references the given internal path, False otherwise 
 hasIdenticalParameters(self, other)

Allows to check if two nodes has the same parameters defined with the same values.

Parameters:other (SBSCompImplWithParams) – the node to compare with
Returns:True if the two nodes has the same parameters, False otherwise 
 initFxMapGraph()

Init the SBSParamsGraph of this filter, if it is a FxMap

Returns:The FxMap graph if success, None otherwise 
 isAFilter()
Returns:True if the CompNode is a Compositing Node Filter, False otherwise. 
 isAFxMap()
Returns:True if the CompNode is a Compositing Node Filter of kind FxMaps, False otherwise. 
 isAPixelProcessor()
Returns:True if the CompNode is a Compositing Node Filter of kind Pixel Processor, False otherwise. 
 isAResource()
Returns:True if the CompNode uses a resource, meaning is a Compositing Node Filter of kind BITMAP or SVG, False otherwise. 
 isAValueProcessor()
Returns:True if the CompNode is a Compositing Node Filter of kind Value Processor, False otherwise. 
 isAnInputBridge()
Returns:True if the CompNode is an Input Bridge, False otherwise. 
 isAnInstance()
Returns:True if the CompNode is a Compositing Node Instance, False otherwise. 
 isAnOutputBridge()
Returns:True if the CompNode is an Output Bridge, False otherwise. 
 isConnectedTo(aLeftNode)

Check if the node is connected to the given node, in the direction aLeftNode -> self

Parameters:aLeftNode (SBSNode or str (UID)) – The node to look for in the connections of this node.
Returns:True if the nodes are connected, False otherwise 
 isDocked()

Check if this node is docked.

Returns:True if this node is docked, None otherwise 
 parse(aContext, aDirAbsPath, aSBSParser, aXmlNode)

Parse recursively the given xml node to retrieve the content of the SBSObject.

Parameters:
  • aContext (Context) – execution context
  • aDirAbsPath (str) – the absolute directory containing the current parsed package (.sbs file)
  • aSBSParser (SBSParser) – the substance parser
  • aXmlNode (xml.etree.ElementTree) – the xml node to parse 
 removeConnectionOnPin(aInput)

Remove the connection on the given input pin.

Parameters:aPinIdentifier (InputEnum or FunctionInputEnum or str) – identifier of the input pin (for SBSCompNode and SBSParamNode) or of the output pin(for SBSParamsGraphNode) to disconnect
Returns:True if a connection is removed, False otherwise 
 removeConnectionsFrom(aLeftNode)

Remove all the connections from aLeftNode to this node (in the direction aLeftNode -> self)

Parameters:aLeftNode (SBSNode or str (UID)) – The node to look for in the connections of this node.
Returns:Nothing 
 setCurveDefinition(aCurveDefinition)

If the node is a Filter Curve, set the given curve definition.

Parameters:aCurveDefinition (CurveDefinition) – curve key values
Returns:True if succeed
Raise:api_exceptions.SBSImpossibleActionError 
 setDynamicParameter(aParameter, aRelativeTo = None)

Set the given parameter as dynamic, to init its params.SBSDynamicValue. If aRelative is None, the default Inheritance will be applied

Parameters:
Returns:

the SBSDynamicValue object if succeed, None otherwise

 
 setGradientMapKeyValues(aKeyValues)

If the node is a Filter Gradient Map, set the given gradient map key values.

Parameters:aKeyValues (list of GradientKey) – gradient key values
Returns:True if succeed
Raise:api_exceptions.SBSImpossibleActionError 
 setParameterSpotColorValueFromIds(aParameter, aBookId, aColorId)

Set the spotcolor parameter to the appropriate comp node implementation

Parameters:
  • aParameterIdentifier – identifier of the parameter to set
  • aBookId (str) – book name
  • aColorId (str) – color name
Returns:

 
 setParameterSpotColorValueFromNames(aParameter, aBookName, aColorName)

Set the spotcolor parameter to the appropriate comp node implementation

Parameters:
  • aParameterIdentifier – identifier of the parameter to set
  • aBookName (str) – book name
  • aColorName (str) – color name
Returns:

 
 setParameterValue(aParameter, aParamValue, aRelativeTo = 0)

Set the parameter to the appropriate comp node implementation

Parameters:
  • aParameter (CompNodeParamEnum or str) – identifier of the parameter to set
  • aParamValue (any parameter type) – value of the parameter
  • aRelativeTo (ParamInheritanceEnum) – Inheritance of the parameter
Returns:

True if success, False otherwise

 
 setPosition(aPosition)

Set the position of this node in the graph GUI.

Parameters:aPosition (a list of 3 float) – The position to set 
 unsetParameter(aParameter)

Unset the given parameter so that it is reset to its default value.

Parameters:aParameter (CompNodeParamEnum or str) – identifier of the parameter to set
Returns:True if succeed, False otherwise 
 write(aSBSWriter, aXmlNode)

Write recursively the content of the SBSObject into the given xml node.

Parameters:
  • aSBSWriter (SBSWriter) – the substance writer
  • aXmlNode (xml.etree.ElementTree) – the xml node to fill

 Adobe

Get help faster and easier

New user?

Quick links

View all your plans Manage your plans
View quick links
Hide quick links

Legal Notices    |    Online Privacy Policy