def test_StaticMethodPosting(self): with self.assertRaises(Tf.ErrorException): Tf._TestStaticMethodError.Error() Tf.Warn("expected warning, for coverage") Tf.Status("expected status message, for coverage")
def testBatching_DelegateRemoved(self): """Tests removing the diagnostic delegate when the batch context is still open.""" self._StartRecording() with mayaUsdLib.DiagnosticBatchContext(): Tf.Warn("this warning won't be lost") Tf.Status("this status won't be lost") cmds.unloadPlugin('pxrUsd', force=True) for i in range(5): Tf.Status("no delegate, this will be lost %d" % i) log = self._StopRecording() # Note: we use assertItemsEqual because coalescing may re-order the # diagnostic messages. self.assertItemsEqual(log, [ ("this warning won't be lost", OM.MCommandMessage.kWarning), ("this status won't be lost", OM.MCommandMessage.kInfo), ])
validate = args.validate if not os.path.isfile(schemaConfig): Tf.RaiseRuntimeError("(%s) json config does not exist" % (schemaConfig)) # Parse json config to extract sdrNodes and schema sublayers try: with open(schemaConfig) as json_file: config = json.load(json_file) except ValueError as ve: Tf.RaiseRuntimeError("Error loading (%s), value error: (%s)" \ %(schemaConfig, ve)) if not isinstance(config, dict): Tf.Warn("Invalid json config provided, expecting a dictionary") sys.exit(1) # Note that for nodes with explicit asset paths, this list stores a tuple, # with first entry being the sdrNode and second the true identifier # (identified from the file basename, which should match the node identifier # when queries using GetShaderNodeByIdentifierAndType at runtime). sdrNodesToParse = [] renderContext = "" sdrNodesDict = config.get(SchemaConfigConstants.SDR_NODES) if sdrNodesDict: # Extract any renderContext from the config if specified. if SchemaConfigConstants.RENDER_CONTEXT in sdrNodesDict.keys(): renderContext = \ sdrNodesDict.get(SchemaConfigConstants.RENDER_CONTEXT)
def _CreateAttrSpecFromNodeAttribute(primSpec, prop, primDefForAttrPruning, schemaPropertyNSPrefixOverride, isInput=True): propMetadata = prop.GetMetadata() # Early out if the property should be suppressed from being translated to # propertySpec if ((PropertyDefiningKeys.USD_SUPPRESS_PROPERTY in propMetadata) and propMetadata[PropertyDefiningKeys.USD_SUPPRESS_PROPERTY] == "True"): return propertyNSPrefixOverride = schemaPropertyNSPrefixOverride if PropertyDefiningKeys.PROPERTY_NS_PREFIX_OVERRIDE in propMetadata: propertyNSPrefixOverride = \ propMetadata[PropertyDefiningKeys.PROPERTY_NS_PREFIX_OVERRIDE] propName = prop.GetName() # Error out if trying to use an explicit propertyNSPrefixOverride on an # output attr if (not isInput and propertyNSPrefixOverride is not None and \ propertyNSPrefixOverride != UsdShade.Tokens.outputs[:-1]): Tf.RaiseRuntimeError("Presence of (%s) output parameter contradicts " \ "the presence of propertyNSPrefixOverride (\"%s\"), as it is " \ "illegal for non-shader nodes to contain output parameters, or " \ "shader nodes' outputs to not have the \"outputs\" namespace " \ "prefix." %(propName, propertyNSPrefixOverride)) attrType = prop.GetTypeAsSdfType()[0] if not Sdf.Path.IsValidNamespacedIdentifier(propName): Tf.RaiseRuntimeError("Property name (%s) for schema (%s) is an " \ "invalid namespace identifier." %(propName, primSpec.name)) # if propertyNSPrefixOverride is provided and we are an output then already # thrown exception # Note that UsdShade inputs and outputs tokens contain the ":" delimiter, so # we need to strip this to be used with JoinIdentifier if propertyNSPrefixOverride is None: propertyNSPrefixOverride = UsdShade.Tokens.inputs[:-1] if isInput else \ UsdShade.Tokens.outputs[:-1] # Apply propertyNSPrefixOverride propName = Sdf.Path.JoinIdentifier([propertyNSPrefixOverride, propName]) # error and early out if duplicate property on primDefForAttrPruning exists # and has different types if primDefForAttrPruning: primDefAttr = primDefForAttrPruning.GetSchemaAttributeSpec(propName) if primDefAttr: usdAttrType = primDefAttr.typeName if (usdAttrType != attrType): Tf.Warn("Generated schema's property type '%s', " "differs usd schema's property type '%s', for " "duplicated property '%s'" %(attrType, usdAttrType, propName)) return # Copy over property parameters options = prop.GetOptions() if options and attrType == Sdf.ValueTypeNames.String: attrType = Sdf.ValueTypeNames.Token attrVariability = Sdf.VariabilityUniform \ if ((PropertyDefiningKeys.USD_VARIABILITY in propMetadata) and propMetadata[PropertyDefiningKeys.USD_VARIABILITY] == PropertyDefiningKeys.SDF_VARIABILITY_UNIFORM_STRING) \ else Sdf.VariabilityVarying attrSpec = Sdf.AttributeSpec(primSpec, propName, attrType, attrVariability) if PropertyDefiningKeys.WIDGET in prop.GetMetadata().keys(): if (prop.GetMetadata()[PropertyDefiningKeys.WIDGET] == \ PropertyDefiningKeys.NULL_VALUE): attrSpec.hidden = True if prop.GetHelp(): attrSpec.documentation = prop.GetHelp() elif prop.GetLabel(): # fallback documentation can be label attrSpec.documentation = prop.GetLabel() if prop.GetPage(): attrSpec.displayGroup = prop.GetPage() if prop.GetLabel(): attrSpec.displayName = prop.GetLabel() if options and attrType == Sdf.ValueTypeNames.Token: # If the value for token list is empty then use the name # If options list has a mix of empty and non-empty value thats an error. tokenList = [] hasEmptyValue = len(options[0][1]) == 0 for option in options: if len(option[1]) == 0: if not hasEmptyValue: Tf.Warn("Property (%s) for schema (%s) has mix of empty " \ "non-empty values for token options (%s)." \ %(propName, primSpec.name, options)) hasEmptyValue = True tokenList.append(option[0]) else: if hasEmptyValue: Tf.Warn("Property (%s) for schema (%s) has mix of empty " \ "non-empty values for token options (%s)." \ %(propName, primSpec.name, options)) hasEmptyValue = False tokenList.append(option[1]) attrSpec.allowedTokens = tokenList defaultValue = prop.GetDefaultValueAsSdfType() if (attrType == Sdf.ValueTypeNames.String or attrType == Sdf.ValueTypeNames.Token) and defaultValue is not None: attrSpec.default = defaultValue.replace('"', r'\"') else: attrSpec.default = defaultValue # The core UsdLux inputs should remain connectable (interfaceOnly) # even if sdrProperty marks the input as not connectable if isInput and not prop.IsConnectable(): attrSpec.SetInfo(PropertyDefiningKeys.CONNECTABILITY, UsdShade.Tokens.interfaceOnly)
def UpdateSchemaWithSdrNode(schemaLayer, sdrNode, renderContext="", overrideIdentifier=""): """ Updates the given schemaLayer with primSpec and propertySpecs from sdrNode metadata. A renderContext can be provided which is used in determining the shaderId namespace, which follows the pattern: "<renderContext>:<SdrShaderNodeContext>:shaderId". Note that we are using a node's context (SDR_NODE_CONTEXT_TOKENS) here to construct the shaderId namespace, so shader parsers should make sure to use appropriate SDR_NODE_CONTEXT_TOKENS in the node definitions. overrideIdentifier parameter is the identifier which should be used when the identifier of the node being processed differs from the one Sdr will discover at runtime, such as when this function is def a node constructed from an explicit asset path. This should only be used when clients know the identifier being passed is the true identifier which sdr Runtime will provide when querying using GetShaderNodeByIdentifierAndType, etc. It consumes the following attributes (that manifest as Sdr metadata) in addition to many of the standard Sdr metadata specified and parsed (via its parser plugin). Node Level Metadata: - "schemaName": Name of the new schema populated from the given sdrNode (Required) - "schemaKind": Specifies the UsdSchemaKind for the schema being populated from the sdrNode. (Note that this does not support multiple apply schema kinds). - "schemaBase": Base schema from which the new schema should inherit from. Note this defaults to "APISchemaBase" for an API schema or "Typed" for a concrete scheme. - "apiSchemasForAttrPruning": A list of core API schemas which will be composed together and any shared shader property from this prim definition is pruned from the resultant schema. - "typedSchemaForAttrPruning": A core typed schema which will be composed together with the apiSchemasForAttrPruning and any shared shader property from this prim definition is pruned from the resultant schema. If no typedSchemaForAttrPruning is provided then only the apiSchemasForAttrPruning are composed to create a prim definition. This will only be used when creating an APISchema. - "apiSchemaAutoApplyTo": The schemas to which the sdrNode populated API schema will autoApply to. - "apiSchemaCanOnlyApplyTo": If specified, the API schema generated from the sdrNode can only be validly applied to this set of schemas. - "providesUsdShadeConnectableAPIBehavior": Used to enable a connectability behavior for an API schema. - "isUsdShadeContainer": Only used when providesUsdShadeConnectableAPIBehavior is set to true. Marks the connectable prim as a UsdShade container type. - "requiresUsdShadeEncapsulation": Only used when providesUsdShadeConnectableAPIBehavior is set to true. Configures the UsdShade encapsulation rules governing its connectableBehavior. - "tfTypeNameSuffix": Class name which will get registered with TfType system. This gets appended to the domain name to register with TfType. - "schemaPropertyNSPrefixOverride": Node level metadata which can drive all node's properties namespace prefix. This can be useful for non connectable nodes which should not get UsdShade inputs and outputs namespace prefix. Property Level Metadata: - "usdVariability": Property level metadata which specifies a specific sdrNodeProperty should have its USD variability set to Uniform or Varying - "usdSuppressProperty": A property level metadata which determines if the property should be suppressed from translation from args to property spec. - "propertyNSPrefixOverride": Provides a way to override a property's namespace from the default (inputs:/outputs:) or from a node's schemaPropertyNSPrefixOverride metadata. Sdr Property Metadata to SdfPropertySpec Translations - A "null" value for Widget sdrProperty metadata translates to SdfPropertySpec Hidden metadata. - SdrProperty's Help metadata (Label metadata if Help metadata not provided) translates to SdfPropertySpec's Documentation string metadata. - SdrProperty's Page metadata translates to SdfPropertySpec's DisplayGroup metadata. - SdrProperty's Label metadata translates to SdfPropertySpec's DisplayName metadata. - SdrProperty's Options translates to SdfPropertySpec's AllowedTokens. - SdrProperty's Default value translates to SdfPropertySpec's Default value. - Connectable input properties translates to InterfaceOnly SdfPropertySpec's CONNECTABILITY. """ import distutils.util import os # Early exit on invalid parameters if not schemaLayer: Tf.Warn("No Schema Layer provided") return if sdrNode is None: # This is a workaround to iterate through invalid sdrNodes (nodes not # having any input or output properties). Currently these nodes return # false when queried for IsValid(). # Refer: pxr/usd/ndr/node.h#140-149 Tf.Warn("No valid sdrNode provided") return sdrNodeMetadata = sdrNode.GetMetadata() if SchemaDefiningKeys.SCHEMA_NAME not in sdrNodeMetadata: Tf.Warn("Sdr Node (%s) does not define a schema name metadata." \ %(sdrNode.GetName())) return schemaName = sdrNodeMetadata[SchemaDefiningKeys.SCHEMA_NAME] if not Tf.IsValidIdentifier(schemaName): Tf.RaiseRuntimeError("schemaName (%s) is an invalid identifier; " "Provide a valid USD identifer for schemaName, example (%s) " %(schemaName, Tf.MakeValidIdentifier(schemaName))) tfTypeNameSuffix = None if SchemaDefiningKeys.TF_TYPENAME_SUFFIX in sdrNodeMetadata: tfTypeNameSuffix = sdrNodeMetadata[SchemaDefiningKeys.TF_TYPENAME_SUFFIX] if not Tf.IsValidIdentifier(tfTypeNameSuffix): Tf.RaiseRuntimeError("tfTypeNameSuffix (%s) is an invalid " \ "identifier" %(tfTypeNameSuffix)) if SchemaDefiningKeys.SCHEMA_KIND not in sdrNodeMetadata: schemaKind = SchemaDefiningMiscConstants.TYPED_SCHEMA else: schemaKind = sdrNodeMetadata[SchemaDefiningKeys.SCHEMA_KIND] # Note: We are not working on dynamic multiple apply schemas right now. isAPI = schemaKind == SchemaDefiningMiscConstants.SINGLE_APPLY_SCHEMA # Fix schemaName and warn if needed if isAPI and \ not schemaName.endswith(SchemaDefiningMiscConstants.API_STRING): Tf.Warn("node metadata implies the generated schema being created is " "an API schema, fixing schemaName to reflect that") schemaName = schemaName + SchemaDefiningMiscConstants.API_STRING if isAPI and tfTypeNameSuffix and \ not tfTypeNameSuffix.endswith(SchemaDefiningMiscConstants.API_STRING): Tf.Warn("node metadata implies the generated schema being created " "is an API schema, fixing tfTypeNameSuffix to reflect that") tfTypeNameSuffix = tfTypeNameSuffix + \ SchemaDefiningMiscConstants.API_STRING if SchemaDefiningKeys.SCHEMA_BASE not in sdrNodeMetadata: Tf.Warn("No schemaBase specified in node metadata, defaulting to " "APISchemaBase for API schemas else Typed") schemaBase = SchemaDefiningMiscConstants.API_SCHEMA_BASE if isAPI \ else SchemaDefiningMiscConstants.TYPED_SCHEMA else: schemaBase = sdrNodeMetadata[SchemaDefiningKeys.SCHEMA_BASE] apiSchemaAutoApplyTo = None if SchemaDefiningKeys.API_SCHEMA_AUTO_APPLY_TO in sdrNodeMetadata: apiSchemaAutoApplyTo = \ sdrNodeMetadata[SchemaDefiningKeys.API_SCHEMA_AUTO_APPLY_TO] \ .split('|') apiSchemaCanOnlyApplyTo = None if SchemaDefiningKeys.API_SCHEMA_CAN_ONLY_APPLY_TO in sdrNodeMetadata: apiSchemaCanOnlyApplyTo = \ sdrNodeMetadata[SchemaDefiningKeys.API_SCHEMA_CAN_ONLY_APPLY_TO] \ .split('|') providesUsdShadeConnectableAPIBehavior = False if SchemaDefiningKeys.PROVIDES_USD_SHADE_CONNECTABLE_API_BEHAVIOR in \ sdrNodeMetadata: providesUsdShadeConnectableAPIBehavior = \ distutils.util.strtobool(sdrNodeMetadata[SchemaDefiningKeys. \ PROVIDES_USD_SHADE_CONNECTABLE_API_BEHAVIOR]) apiSchemasForAttrPruning = None if SchemaDefiningKeys.API_SCHEMAS_FOR_ATTR_PRUNING in sdrNodeMetadata: apiSchemasForAttrPruning = \ sdrNodeMetadata[SchemaDefiningKeys.API_SCHEMAS_FOR_ATTR_PRUNING] \ .split('|') typedSchemaForAttrPruning = "" if isAPI and \ SchemaDefiningKeys.TYPED_SCHEMA_FOR_ATTR_PRUNING in sdrNodeMetadata: typedSchemaForAttrPruning = \ sdrNodeMetadata[SchemaDefiningKeys.TYPED_SCHEMA_FOR_ATTR_PRUNING] schemaPropertyNSPrefixOverride = None if SchemaDefiningKeys.SCHEMA_PROPERTY_NS_PREFIX_OVERRIDE in sdrNodeMetadata: schemaPropertyNSPrefixOverride = \ sdrNodeMetadata[ \ SchemaDefiningKeys.SCHEMA_PROPERTY_NS_PREFIX_OVERRIDE] usdSchemaReg = Usd.SchemaRegistry() # determine if the node being processed provides UsdShade-Connectability, # this helps in determining what namespace to use and also to report error # if a non-connectable node has outputs properties, which is malformed. # - Does the node derive from a schemaBase which provides connectable # behavior. Warn if schemaPropertyNSPrefixOverride is also specified, as # these metadata won't be used. # - If no schemaBase then we default to UsdShade connectable node's # inputs:/outputs: namespace prefix, unless schemaPropertyNSPrefixOverride # is provided. # - We also report an error if schemaPropertyNSPrefixOverride is provided # and an output property is found on the node being processed. schemaBaseProvidesConnectability = UsdShade.ConnectableAPI. \ HasConnectableAPI(usdSchemaReg.GetTypeFromName(schemaBase)) if (len(sdrNode.GetOutputNames()) > 0 and \ schemaPropertyNSPrefixOverride is not None and \ not _IsNSPrefixConnectableAPICompliant( \ schemaPropertyNSPrefixOverride)): Tf.RaiseRuntimeError("Presence of (%s) output parameters contradicts " \ "the presence of schemaPropertyNSPrefixOverride (\"%s\"), as it " \ "is illegal for non-connectable nodes to contain output " \ "parameters, or shader nodes' outputs to not have the \"outputs\"" \ "namespace prefix." %(len(sdrNode.GetOutputNames()), \ schemaPropertyNSPrefixOverride)) if (schemaBaseProvidesConnectability and \ schemaPropertyNSPrefixOverride is not None and \ not _IsNSPrefixConnectableAPICompliant( \ schemaPropertyNSPrefixOverride)): Tf.Warn("Node %s provides UsdShade-Connectability as it derives from " \ "%s, schemaPropertyNSPrefixOverride \"%s\" will not be used." \ %(schemaName, schemaBase, schemaPropertyNSPrefixOverride)) # set schemaPropertyNSPrefixOverride to "inputs", assuming default # UsdShade Connectability namespace prefix schemaPropertyNSPrefixOverride = "inputs" primSpec = schemaLayer.GetPrimAtPath(schemaName) if (primSpec): # if primSpec already exist, remove entirely and recreate using the # parsed sdr node if primSpec.nameParent: del primSpec.nameParent.nameChildren[primSpec.name] else: del primSpec.nameRoot.nameChildren[primSpec.name] primSpec = Sdf.PrimSpec(schemaLayer, schemaName, Sdf.SpecifierClass, "" if isAPI else schemaName) primSpec.inheritPathList.explicitItems = ["/" + schemaBase] primSpecCustomData = {} if isAPI: primSpecCustomData["apiSchemaType"] = schemaKind if tfTypeNameSuffix: # Defines this classname for TfType system # can help avoid duplicate prefix with domain and className # Tf type system will automatically pick schemaName as tfTypeName if # this is not set! primSpecCustomData["className"] = tfTypeNameSuffix if apiSchemaAutoApplyTo: primSpecCustomData['apiSchemaAutoApplyTo'] = \ Vt.TokenArray(apiSchemaAutoApplyTo) if apiSchemaCanOnlyApplyTo: primSpecCustomData['apiSchemaCanOnlyApplyTo'] = \ Vt.TokenArray(apiSchemaCanOnlyApplyTo) if providesUsdShadeConnectableAPIBehavior: extraPlugInfo = { SchemaDefiningKeys.PROVIDES_USD_SHADE_CONNECTABLE_API_BEHAVIOR \ : True } for propKey in [SchemaDefiningKeys.IS_USD_SHADE_CONTAINER, \ SchemaDefiningKeys.REQUIRES_USD_SHADE_ENCAPSULATION]: if propKey in sdrNodeMetadata: # Since we want to assign the types for these to bool and # because in python boolean type is a subset of int, we need to # do following instead of assign the propValue directly. propValue = distutils.util.strtobool(sdrNodeMetadata[propKey]) extraPlugInfo[propKey] = bool(propValue) primSpecCustomData['extraPlugInfo'] = extraPlugInfo primSpec.customData = primSpecCustomData doc = sdrNode.GetHelp() if doc != "": primSpec.documentation = doc # gather properties from a prim definition generated by composing apiSchemas # provided by apiSchemasForAttrPruning metadata. primDefForAttrPruning = None if apiSchemasForAttrPruning: primDefForAttrPruning = usdSchemaReg.BuildComposedPrimDefinition( typedSchemaForAttrPruning, apiSchemasForAttrPruning) # Create attrSpecs from input parameters for propName in sdrNode.GetInputNames(): _CreateAttrSpecFromNodeAttribute(primSpec, sdrNode.GetInput(propName), primDefForAttrPruning, schemaPropertyNSPrefixOverride) # Create attrSpecs from output parameters # Note that we always want outputs: namespace prefix for output attributes. for propName in sdrNode.GetOutputNames(): _CreateAttrSpecFromNodeAttribute(primSpec, sdrNode.GetOutput(propName), primDefForAttrPruning, UsdShade.Tokens.outputs[:-1], False) # Create token shaderId attrSpec -- only for shader nodes if (schemaBaseProvidesConnectability or \ schemaPropertyNSPrefixOverride is None or \ _IsNSPrefixConnectableAPICompliant(schemaPropertyNSPrefixOverride)): shaderIdAttrName = Sdf.Path.JoinIdentifier( \ [renderContext, sdrNode.GetContext(), PropertyDefiningKeys.SHADER_ID]) shaderIdAttrSpec = Sdf.AttributeSpec(primSpec, shaderIdAttrName, Sdf.ValueTypeNames.Token, Sdf.VariabilityUniform) # Since users shouldn't need to be aware of shaderId attribute, we put # this in "Internal" displayGroup. shaderIdAttrSpec.displayGroup = \ PropertyDefiningKeys.INTERNAL_DISPLAY_GROUP # Use the identifier if explicitly provided, (it could be a shader node # queried using an explicit path), else use sdrNode's registered # identifier. nodeIdentifier = overrideIdentifier if overrideIdentifier else \ sdrNode.GetIdentifier() shaderIdAttrSpec.default = nodeIdentifier # Extra attrSpec schemaBasePrimDefinition = \ Usd.SchemaRegistry().FindConcretePrimDefinition(schemaBase) if schemaBasePrimDefinition and \ SchemaDefiningMiscConstants.NodeDefAPI in \ schemaBasePrimDefinition.GetAppliedAPISchemas(): infoIdAttrSpec = Sdf.AttributeSpec(primSpec, \ UsdShade.Tokens.infoId, Sdf.ValueTypeNames.Token, \ Sdf.VariabilityUniform) infoIdAttrSpec.default = nodeIdentifier schemaLayer.Save()
def _CreateAttrSpecFromNodeAttribute(primSpec, prop, usdSchemaNode, isInput=True): propName = prop.GetName() attrType = prop.GetTypeAsSdfType()[0] # error and early out if duplicate property on usdSchemaNode exists and has # different types if usdSchemaNode: usdSchemaNodeProp = usdSchemaNode.GetInput(propName) if isInput else \ usdSchemaNode.GetOutput(propName) if usdSchemaNodeProp: usdAttrType = usdSchemaNodeProp.GetTypeAsSdfType()[0] if (usdAttrType != attrType): Tf.Warn("Generated schema's property type '%s', " "differs usd schema's property type '%s', for " "duplicated property '%s'" % (attrType, usdAttrType, propName)) return propMetadata = prop.GetMetadata() if not Sdf.Path.IsValidNamespacedIdentifier(propName): Tf.RaiseRuntimeError("Property name (%s) for schema (%s) is an " \ "invalid namespace identifier." %(propName, primSpec.name)) # Apply input/output prefix # Note that UsdShade inputs and outputs tokens contain the ":" delimiter, so # we need to strip this to be used with JoinIdentifier propName = Sdf.Path.JoinIdentifier( \ [UsdShade.Tokens.inputs[:-1], propName]) \ if isInput else \ Sdf.Path.JoinIdentifier( \ [UsdShade.Tokens.outputs[:-1], propName]) # Copy over property parameters options = prop.GetOptions() if options and attrType == Sdf.ValueTypeNames.String: attrType = Sdf.ValueTypeNames.Token attrVariability = Sdf.VariabilityUniform \ if (propMetadata.has_key( PropertyDefiningKeys.USD_VARIABILITY) and \ propMetadata[PropertyDefiningKeys.USD_VARIABILITY] == PropertyDefiningKeys.SDF_VARIABILITY_UNIFORM_STRING) \ else Sdf.VariabilityVarying attrSpec = Sdf.AttributeSpec(primSpec, propName, attrType, attrVariability) if prop.GetHelp(): attrSpec.documentation = prop.GetHelp() elif prop.GetLabel(): # fallback documentation can be label attrSpec.documentation = prop.GetLabel() if prop.GetPage(): attrSpec.displayGroup = prop.GetPage() if prop.GetLabel(): attrSpec.displayName = prop.GetLabel() if options and attrType == Sdf.ValueTypeNames.Token: attrSpec.allowedTokens = [x[1] for x in options] attrSpec.default = prop.GetDefaultValue() # The core UsdLux inputs should remain connectable (interfaceOnly) # even if sdrProperty marks the input as not connectable if isInput and not prop.IsConnectable(): attrSpec.SetInfo(PropertyDefiningKeys.CONNECTABILITY, UsdShade.Tokens.interfaceOnly)
def UpdateSchemaWithSdrNode(schemaLayer, sdrNode): """ Updates the given schemaLayer with primSpec and propertySpecs from sdrNode metadata. It consume the following attributes (that manifest as Sdr metadata) in addition to many of the standard Sdr metadata specified and parsed (via its parser plugin). Node Level Metadata: - "schemaName": Name of the new schema populated from the given sdrNode (Required) - "schemaKind": Specifies the UsdSchemaKind for the schema being populated from the sdrNode. (note that this does not support multi-applied schema kinds). - "schemaBase": Base schema from which the new schema should inherit from. Note this defaults to "APISchemaBase" for an api schema or "Typed" for a concrete scheme. - "usdSchemaClass": Specified the equivalent schema directly generated by USD (sourceType: USD). This is used to make sure duplicate properties already specified in the USD schema are not populated in the new API schema. Note this is only used when we are dealing with an API schema. - "apiSchemaAutoApplyTo": The Schemas to which the sdrNode populated (API) schema will autoApply to. - "tfTypeNameSuffix": Class name which will get registered with TfType system. This gets appended to the domain name to register with TfType. Property Level Metadata: USD_VARIABILITY = A property level metadata, which specified a specific sdrNodeProperty should its usd variability set to Uniform or Varying. """ # Early exit on invalid parameters if not schemaLayer: Tf.Warn("No Schema Layer provided") return if not sdrNode: Tf.Warn("No valid sdrNode provided") return sdrNodeMetadata = sdrNode.GetMetadata() if not sdrNodeMetadata.has_key(SchemaDefiningKeys.SCHEMA_NAME): Tf.Warn("Sdr Node does not define a schema name metadata.") return schemaName = sdrNodeMetadata[SchemaDefiningKeys.SCHEMA_NAME] if not Tf.IsValidIdentifier(schemaName): Tf.RaiseRuntimeError( "schemaName (%s) is an invalid identifier; " "Provide a valid USD identifer for schemaName, example (%s) " % (schemaName, Tf.MakeValidIdentifier(schemaName))) tfTypeNameSuffix = None if sdrNodeMetadata.has_key(SchemaDefiningKeys.TF_TYPENAME_SUFFIX): tfTypeNameSuffix = sdrNodeMetadata[ SchemaDefiningKeys.TF_TYPENAME_SUFFIX] if not Tf.IsValidIdentifier(tfTypeNameSuffix): Tf.RaiseRuntimeError("tfTypeNameSuffix (%s) is an invalid " \ "identifier" %(tfTypeNameSuffix)) if not sdrNodeMetadata.has_key(SchemaDefiningKeys.SCHEMA_KIND): schemaKind = SchemaDefiningMiscConstants.TYPED_SCHEMA else: schemaKind = sdrNodeMetadata[SchemaDefiningKeys.SCHEMA_KIND] # Note: We are not working on dynamic multiapply schemas right now. isAPI = schemaKind == SchemaDefiningMiscConstants.SINGLE_APPLY_SCHEMA # Fix schemaName and warn if needed if isAPI and \ not schemaName.endswith(SchemaDefiningMiscConstants.API_STRING): Tf.Warn("node metadata implies the generated schema being created is " "an API schema, fixing schemaName to reflect that") schemaName = schemaName + SchemaDefiningMiscConstants.API_STRING if isAPI and tfTypeNameSuffix and \ not tfTypeNameSuffix.endswith(SchemaDefiningMiscConstants.API_STRING): Tf.Warn("node metadata implies the generated schema being created " "is an API schema, fixing tfTypeNameSuffix to reflect that") tfTypeNameSuffix = tfTypeNameSuffix + \ SchemaDefiningMiscConstants.API_STRING if not sdrNodeMetadata.has_key(SchemaDefiningKeys.SCHEMA_BASE): Tf.Warn("No schemaBase specified in node metadata, defaulting to " "APISchemaBase for API schemas else Typed") schemaBase = SchemaDefiningMiscConstants.API_SCHEMA_BASE if isAPI \ else SchemaDefiningMiscConstants.TYPED_SCHEMA else: schemaBase = sdrNodeMetadata[SchemaDefiningKeys.SCHEMA_BASE] apiSchemaAutoApplyTo = None if sdrNodeMetadata.has_key(SchemaDefiningKeys.API_SCHEMA_AUTO_APPLY_TO): apiSchemaAutoApplyTo = \ sdrNodeMetadata[SchemaDefiningKeys.API_SCHEMA_AUTO_APPLY_TO] \ .split('|') usdSchemaClass = None if isAPI and sdrNodeMetadata.has_key(SchemaDefiningKeys.USD_SCHEMA_CLASS): usdSchemaClass = \ sdrNodeMetadata[SchemaDefiningKeys.USD_SCHEMA_CLASS] primSpec = schemaLayer.GetPrimAtPath(schemaName) if (primSpec): # if primSpec already exist, remove entirely and recreate using the # parsed sdr node if primSpec.nameParent: del primSpec.nameParent.nameChildren[primSpec.name] else: del primSpec.nameRoot.nameChildren[primSpec.name] primSpec = Sdf.PrimSpec(schemaLayer, schemaName, Sdf.SpecifierClass, "" if isAPI else schemaName) primSpec.inheritPathList.explicitItems = ["/" + schemaBase] primSpecCustomData = {} if isAPI: primSpecCustomData["apiSchemaType"] = schemaKind if tfTypeNameSuffix: # Defines this classname for TfType system # can help avoid duplicate prefix with domain and className # Tf type system will automatically pick schemaName as tfTypeName if # this is not set! primSpecCustomData["className"] = tfTypeNameSuffix if apiSchemaAutoApplyTo: primSpecCustomData['apiSchemaAutoApplyTo'] = \ Vt.TokenArray(apiSchemaAutoApplyTo) primSpec.customData = primSpecCustomData doc = sdrNode.GetHelp() if doc != "": primSpec.documentation = doc # gather properties from node directly generated from USD (sourceType: USD) # Use the usdSchemaClass tag when the generated schema being defined is an # API schema usdSchemaNode = None if usdSchemaClass: reg = Sdr.Registry() usdSchemaNode = reg.GetNodeByIdentifierAndType( usdSchemaClass, SchemaDefiningMiscConstants.USD_SOURCE_TYPE) # Create attrSpecs from input parameters for propName in sdrNode.GetInputNames(): _CreateAttrSpecFromNodeAttribute(primSpec, sdrNode.GetInput(propName), usdSchemaNode) # Create attrSpecs from output parameters for propName in sdrNode.GetOutputNames(): _CreateAttrSpecFromNodeAttribute(primSpec, sdrNode.GetOutput(propName), usdSchemaNode, False) schemaLayer.Save()
def _genWarning(): Tf.Warn('.')
def testCase14a(): print("Case14a: test TfWarning filtering - no aborts") delegate = delegateSetup(None, ["*test*"], ["*not*"], None) Tf.Warn("does not abort - word not excluded") Tf.Warn("lets not abort - word not excluded") Tf.Warn("abort not please - word not excluded")
def UpdateSchemaWithSdrNode(schemaLayer, sdrNode, renderContext="", overrideIdentifier=""): """ Updates the given schemaLayer with primSpec and propertySpecs from sdrNode metadata. A renderContext can be provided which is used in determining the shaderId namespace, which follows the pattern: "<renderContext>:<SdrShaderNodeContext>:shaderId". Note that we are using a node's context (SDR_NODE_CONTEXT_TOKENS) here to construct the shaderId namespace, so shader parsers should make sure to use appropriate SDR_NODE_CONTEXT_TOKENS in the node definitions. overrideIdentifier parameter is the identifier which should be used when the identifier of the node being processed differs from the one Sdr will discover at runtime, such as when this function is def a node constructed from an explicit asset path. This should only be used when clients know the identifier being passed is the true identifier which sdr Runtime will provide when querying using GetShaderNodeByNameAndType, etc. It consumes the following attributes (that manifest as Sdr metadata) in addition to many of the standard Sdr metadata specified and parsed (via its parser plugin). Node Level Metadata: - "schemaName": Name of the new schema populated from the given sdrNode (Required) - "schemaKind": Specifies the UsdSchemaKind for the schema being populated from the sdrNode. (Note that this does not support multiple apply schema kinds). - "schemaBase": Base schema from which the new schema should inherit from. Note this defaults to "APISchemaBase" for an API schema or "Typed" for a concrete scheme. - "usdSchemaClass": Specifies the equivalent schema directly generated by USD (sourceType: USD). This is used to make sure duplicate properties already specified in the USD schema are not populated in the new API schema. Note this is only used when we are dealing with an API schema. - "apiSchemaAutoApplyTo": The schemas to which the sdrNode populated API schema will autoApply to. - "apiSchemaCanOnlyApplyTo": If specified, the API schema generated from the sdrNode can only be validly applied to this set of schemas. - "providesUsdShadeConnectableAPIBehavior": Used to enable a connectability behavior for an API schema. - "isUsdShadeContainer": Only used when providesUsdShadeConnectableAPIBehavior is set to true. Marks the connectable prim as a UsdShade container type. - "requiresUsdShadeEncapsulation": Only used when providesUsdShadeConnectableAPIBehavior is set to true. Configures the UsdShade encapsulation rules governing its connectableBehavior. - "tfTypeNameSuffix": Class name which will get registered with TfType system. This gets appended to the domain name to register with TfType. Property Level Metadata: - USD_VARIABILITY: Property level metadata which specifies a specific sdrNodeProperty should have its USD variability set to Uniform or Varying - USD_SUPPRESS_PROPERTY: A property level metadata which determines if the property should be suppressed from translation from args to property spec. Sdr Property Metadata to SdfPropertySpec Translations - A "null" value for Widget sdrProperty metadata translates to SdfPropertySpec Hidden metadata. - SdrProperty's Help metadata (Label metadata if Help metadata not provided) translates to SdfPropertySpec's Documentation string metadata. - SdrProperty's Page metadata translates to SdfPropertySpec's DisplayGroup metadata. - SdrProperty's Label metadata translates to SdfPropertySpec's DisplayName metadata. - SdrProperty's Options translates to SdfPropertySpec's AllowedTokens. - SdrProperty's Default value translates to SdfPropertySpec's Default value. - Connectable input properties translates to InterfaceOnly SdfPropertySpec's CONNECTABILITY. """ import distutils.util import os # Early exit on invalid parameters if not schemaLayer: Tf.Warn("No Schema Layer provided") return if not sdrNode: Tf.Warn("No valid sdrNode provided") return sdrNodeMetadata = sdrNode.GetMetadata() if SchemaDefiningKeys.SCHEMA_NAME not in sdrNodeMetadata: Tf.Warn("Sdr Node (%s) does not define a schema name metadata." \ %(sdrNode.GetName())) return schemaName = sdrNodeMetadata[SchemaDefiningKeys.SCHEMA_NAME] if not Tf.IsValidIdentifier(schemaName): Tf.RaiseRuntimeError( "schemaName (%s) is an invalid identifier; " "Provide a valid USD identifer for schemaName, example (%s) " % (schemaName, Tf.MakeValidIdentifier(schemaName))) tfTypeNameSuffix = None if SchemaDefiningKeys.TF_TYPENAME_SUFFIX in sdrNodeMetadata: tfTypeNameSuffix = sdrNodeMetadata[ SchemaDefiningKeys.TF_TYPENAME_SUFFIX] if not Tf.IsValidIdentifier(tfTypeNameSuffix): Tf.RaiseRuntimeError("tfTypeNameSuffix (%s) is an invalid " \ "identifier" %(tfTypeNameSuffix)) if SchemaDefiningKeys.SCHEMA_KIND not in sdrNodeMetadata: schemaKind = SchemaDefiningMiscConstants.TYPED_SCHEMA else: schemaKind = sdrNodeMetadata[SchemaDefiningKeys.SCHEMA_KIND] # Note: We are not working on dynamic multiple apply schemas right now. isAPI = schemaKind == SchemaDefiningMiscConstants.SINGLE_APPLY_SCHEMA # Fix schemaName and warn if needed if isAPI and \ not schemaName.endswith(SchemaDefiningMiscConstants.API_STRING): Tf.Warn("node metadata implies the generated schema being created is " "an API schema, fixing schemaName to reflect that") schemaName = schemaName + SchemaDefiningMiscConstants.API_STRING if isAPI and tfTypeNameSuffix and \ not tfTypeNameSuffix.endswith(SchemaDefiningMiscConstants.API_STRING): Tf.Warn("node metadata implies the generated schema being created " "is an API schema, fixing tfTypeNameSuffix to reflect that") tfTypeNameSuffix = tfTypeNameSuffix + \ SchemaDefiningMiscConstants.API_STRING if SchemaDefiningKeys.SCHEMA_BASE not in sdrNodeMetadata: Tf.Warn("No schemaBase specified in node metadata, defaulting to " "APISchemaBase for API schemas else Typed") schemaBase = SchemaDefiningMiscConstants.API_SCHEMA_BASE if isAPI \ else SchemaDefiningMiscConstants.TYPED_SCHEMA else: schemaBase = sdrNodeMetadata[SchemaDefiningKeys.SCHEMA_BASE] apiSchemaAutoApplyTo = None if SchemaDefiningKeys.API_SCHEMA_AUTO_APPLY_TO in sdrNodeMetadata: apiSchemaAutoApplyTo = \ sdrNodeMetadata[SchemaDefiningKeys.API_SCHEMA_AUTO_APPLY_TO] \ .split('|') apiSchemaCanOnlyApplyTo = None if SchemaDefiningKeys.API_SCHEMA_CAN_ONLY_APPLY_TO in sdrNodeMetadata: apiSchemaCanOnlyApplyTo = \ sdrNodeMetadata[SchemaDefiningKeys.API_SCHEMA_CAN_ONLY_APPLY_TO] \ .split('|') providesUsdShadeConnectableAPIBehavior = False if SchemaDefiningKeys.PROVIDES_USD_SHADE_CONNECTABLE_API_BEHAVIOR in \ sdrNodeMetadata: providesUsdShadeConnectableAPIBehavior = \ distutils.util.strtobool(sdrNodeMetadata[SchemaDefiningKeys. \ PROVIDES_USD_SHADE_CONNECTABLE_API_BEHAVIOR]) usdSchemaClass = None if isAPI and SchemaDefiningKeys.USD_SCHEMA_CLASS in sdrNodeMetadata: usdSchemaClass = \ sdrNodeMetadata[SchemaDefiningKeys.USD_SCHEMA_CLASS] primSpec = schemaLayer.GetPrimAtPath(schemaName) if (primSpec): # if primSpec already exist, remove entirely and recreate using the # parsed sdr node if primSpec.nameParent: del primSpec.nameParent.nameChildren[primSpec.name] else: del primSpec.nameRoot.nameChildren[primSpec.name] primSpec = Sdf.PrimSpec(schemaLayer, schemaName, Sdf.SpecifierClass, "" if isAPI else schemaName) primSpec.inheritPathList.explicitItems = ["/" + schemaBase] primSpecCustomData = {} if isAPI: primSpecCustomData["apiSchemaType"] = schemaKind if tfTypeNameSuffix: # Defines this classname for TfType system # can help avoid duplicate prefix with domain and className # Tf type system will automatically pick schemaName as tfTypeName if # this is not set! primSpecCustomData["className"] = tfTypeNameSuffix if apiSchemaAutoApplyTo: primSpecCustomData['apiSchemaAutoApplyTo'] = \ Vt.TokenArray(apiSchemaAutoApplyTo) if apiSchemaCanOnlyApplyTo: primSpecCustomData['apiSchemaCanOnlyApplyTo'] = \ Vt.TokenArray(apiSchemaCanOnlyApplyTo) if providesUsdShadeConnectableAPIBehavior: extraPlugInfo = { SchemaDefiningKeys.PROVIDES_USD_SHADE_CONNECTABLE_API_BEHAVIOR \ : True } for propKey in [SchemaDefiningKeys.IS_USD_SHADE_CONTAINER, \ SchemaDefiningKeys.REQUIRES_USD_SHADE_ENCAPSULATION]: if propKey in sdrNodeMetadata: # Since we want to assign the types for these to bool and # because in python boolean type is a subset of int, we need to # do following instead of assign the propValue directly. propValue = distutils.util.strtobool(sdrNodeMetadata[propKey]) extraPlugInfo[propKey] = bool(propValue) primSpecCustomData['extraPlugInfo'] = extraPlugInfo primSpec.customData = primSpecCustomData doc = sdrNode.GetHelp() if doc != "": primSpec.documentation = doc # gather properties from node directly generated from USD (sourceType: USD) # Use the usdSchemaClass tag when the generated schema being defined is an # API schema usdSchemaNode = None if usdSchemaClass: reg = Sdr.Registry() if usdSchemaClass.endswith(SchemaDefiningMiscConstants.API_STRING): # This usd schema is an API schema, we need to extract the shader # identifier from its primDef's shaderId field. primDef = Usd.SchemaRegistry().FindAppliedAPIPrimDefinition( usdSchemaClass) if primDef: # We are dealing with USD source type here, hence no render # context is required but we can still borrow node context # information from the sdrNode in question, since the usd source # type node should also belong to the same context. shaderIdAttrName = Sdf.Path.JoinIdentifier( \ sdrNode.GetContext(), PropertyDefiningKeys.SHADER_ID) sdrIdentifier = primDef.GetAttributeFallbackValue( shaderIdAttrName) if sdrIdentifier != "": usdSchemaNode = reg.GetNodeByIdentifierAndType( sdrIdentifier, SchemaDefiningMiscConstants.USD_SOURCE_TYPE) else: Tf.Warn("No sourceId authored for '%s'." % (usdSchemaClass)) else: Tf.Warn("Illegal API schema provided for the usdSchemaClass " "metadata. No prim definition registered for '%s'" % (usdSchemaClass)) else: usdSchemaNode = reg.GetNodeByIdentifierAndType( usdSchemaClass, SchemaDefiningMiscConstants.USD_SOURCE_TYPE) # Create attrSpecs from input parameters for propName in sdrNode.GetInputNames(): _CreateAttrSpecFromNodeAttribute(primSpec, sdrNode.GetInput(propName), usdSchemaNode) # Create attrSpecs from output parameters for propName in sdrNode.GetOutputNames(): _CreateAttrSpecFromNodeAttribute(primSpec, sdrNode.GetOutput(propName), usdSchemaNode, False) # Create token shaderId attrSpec shaderIdAttrName = Sdf.Path.JoinIdentifier( \ [renderContext, sdrNode.GetContext(), PropertyDefiningKeys.SHADER_ID]) shaderIdAttrSpec = Sdf.AttributeSpec(primSpec, shaderIdAttrName, Sdf.ValueTypeNames.Token, Sdf.VariabilityUniform) # Since users shouldn't need to be aware of shaderId attribute, we put this # in "Internal" displayGroup. shaderIdAttrSpec.displayGroup = PropertyDefiningKeys.INTERNAL_DISPLAY_GROUP # Use the identifier if explicitly provided, (it could be a shader node # queried using an explicit path), else use sdrNode's registered identifier. nodeIdentifier = overrideIdentifier if overrideIdentifier else \ sdrNode.GetIdentifier() shaderIdAttrSpec.default = nodeIdentifier # Extra attrSpec schemaBasePrimDefinition = \ Usd.SchemaRegistry().FindConcretePrimDefinition(schemaBase) if schemaBasePrimDefinition and \ SchemaDefiningMiscConstants.NodeDefAPI in \ schemaBasePrimDefinition.GetAppliedAPISchemas(): infoIdAttrSpec = Sdf.AttributeSpec(primSpec, \ UsdShade.Tokens.infoId, Sdf.ValueTypeNames.Token, \ Sdf.VariabilityUniform) infoIdAttrSpec.default = nodeIdentifier schemaLayer.Save()