@tushar-br/editing-pack 1.0.194 → 1.0.195

package/staging_area/Blender/blender.shared/usd/usd/resources/codegenTemplates/wrapSchemaClass.cpp

@@ -0,0 +1,328 @@
+//
+// Copyright 2016 Pixar
+//
+// Licensed under the terms set forth in the LICENSE.txt file available at
+// https://openusd.org/license.
+//
+#include "{{ libraryPath }}/{{ cls.GetHeaderFile() }}"
+#include "pxr/usd/usd/schemaBase.h"
+
+#include "pxr/usd/sdf/primSpec.h"
+
+#include "pxr/usd/usd/pyConversions.h"
+{% if cls.isAppliedAPISchema %}
+#include "pxr/base/tf/pyAnnotatedBoolResult.h"
+{% endif %}
+#include "pxr/base/tf/pyContainerConversions.h"
+#include "pxr/base/tf/pyResultConversions.h"
+#include "pxr/base/tf/pyUtils.h"
+#include "pxr/base/tf/wrapTypeHelpers.h"
+
+#include "pxr/external/boost/python.hpp"
+
+#include <string>
+
+{% if useExportAPI %}
+{{ namespaceUsing }}
+
+using namespace pxr_boost::python;
+
+namespace {
+
+{% else %}
+using namespace pxr_boost::python;
+
+{% endif %}
+#define WRAP_CUSTOM                                                     \
+    template <class Cls> static void _CustomWrapCode(Cls &_class)
+
+// fwd decl.
+WRAP_CUSTOM;
+
+{% for attrName in cls.attrOrder -%}
+{% set attr = cls.attrs[attrName] %}
+{# Only emit Create/Get API if apiName is not empty string. #}
+{% if attr.apiName != '' %}
+        
+static UsdAttribute
+_Create{{ Proper(attr.apiName) }}Attr({{ cls.cppClassName }} &self,
+                                      object defaultVal, bool writeSparsely) {
+    return self.Create{{ Proper(attr.apiName) }}Attr(
+        UsdPythonToSdfType(defaultVal, {{ attr.usdType }}), writeSparsely);
+}
+{% endif %}
+{% endfor %}
+{% if cls.isMultipleApply and cls.propertyNamespace %}
+
+static bool _WrapIs{{ cls.usdPrimTypeName }}Path(const SdfPath &path) {
+    TfToken collectionName;
+    return {{ cls.cppClassName }}::Is{{ cls.usdPrimTypeName }}Path(
+        path, &collectionName);
+}
+{% endif %}
+{% if not cls.isAPISchemaBase %}
+
+static std::string
+_Repr(const {{ cls.cppClassName }} &self)
+{
+    std::string primRepr = TfPyRepr(self.GetPrim());
+{% if cls.isMultipleApply %}
+    std::string instanceName = TfPyRepr(self.GetName());
+    return TfStringPrintf(
+        "{{ libraryName[0]|upper }}{{ libraryName[1:] }}.{{ cls.className }}(%s, '%s')",
+        primRepr.c_str(), instanceName.c_str());
+{% else %}
+    return TfStringPrintf(
+        "{{ libraryName[0]|upper }}{{ libraryName[1:] }}.{{ cls.className }}(%s)",
+        primRepr.c_str());
+{% endif %}
+}
+{% endif %}
+{% if cls.isAppliedAPISchema %}
+
+struct {{ cls.cppClassName }}_CanApplyResult : 
+    public TfPyAnnotatedBoolResult<std::string>
+{
+    {{ cls.cppClassName }}_CanApplyResult(bool val, std::string const &msg) :
+        TfPyAnnotatedBoolResult<std::string>(val, msg) {}
+};
+
+{% if cls.isMultipleApply %}
+static {{ cls.cppClassName }}_CanApplyResult
+_WrapCanApply(const UsdPrim& prim, const TfToken& name)
+{
+    std::string whyNot;
+    bool result = {{ cls.cppClassName }}::CanApply(prim, name, &whyNot);
+    return {{ cls.cppClassName }}_CanApplyResult(result, whyNot);
+}
+{% else %}
+static {{ cls.cppClassName }}_CanApplyResult
+_WrapCanApply(const UsdPrim& prim)
+{
+    std::string whyNot;
+    bool result = {{ cls.cppClassName }}::CanApply(prim, &whyNot);
+    return {{ cls.cppClassName }}_CanApplyResult(result, whyNot);
+}
+{% endif %}
+{% endif %}
+{% if useExportAPI %}
+
+{% for schema in appliedSchemas %}
+{% set schemaCls = classes[schema]%}
+{% for attrName in schemaCls.attrOrder -%}
+{% set attr = schemaCls.attrs[attrName] %}
+{# Only emit Create/Get API if apiName is not empty string. #}
+{% if attr.apiName != '' %}
+        
+static UsdAttribute
+_Create{{ Proper(attr.apiName) }}Attr({{ cls.cppClassName }} &self,
+                                      object defaultVal, bool writeSparsely) {
+    return self.Create{{ Proper(attr.apiName) }}Attr(
+        UsdPythonToSdfType(defaultVal, {{ attr.usdType }}), writeSparsely);
+}
+{% endif %}
+{% endfor %}
+{% if schemaCls.isMultipleApply and schemaCls.propertyNamespace %}
+
+static bool _WrapIs{{ schemaCls.usdPrimTypeName }}Path(const SdfPath &path) {
+    TfToken collectionName;
+    return {{ schemaCls.cppClassName }}::Is{{ cls.usdPrimTypeName }}Path(
+        path, &collectionName);
+}
+{% endif %}
+{% endfor %}
+} // anonymous namespace
+{% endif %}
+
+void wrap{{ cls.cppClassName }}()
+{
+    typedef {{ cls.cppClassName }} This;
+
+{% if cls.isAppliedAPISchema %}
+    {{ cls.cppClassName }}_CanApplyResult::Wrap<{{ cls.cppClassName }}_CanApplyResult>(
+        "_CanApplyResult", "whyNot");
+
+{% endif %}
+{% if cls.isAPISchemaBase %}
+    class_< This , bases<{{ cls.parentCppClassName }}>, noncopyable> cls ("APISchemaBase", "", no_init);
+{% else %}
+    class_<This, bases<{{ cls.parentCppClassName }}> >
+        cls("{{ cls.className }}");
+{% endif %}
+
+    cls
+{% if not cls.isAPISchemaBase %}
+{% if cls.isMultipleApply %}
+        .def(init<UsdPrim, TfToken>((arg("prim"), arg("name"))))
+        .def(init<UsdSchemaBase const&, TfToken>((arg("schemaObj"), arg("name"))))
+{% else %}
+        .def(init<UsdPrim>(arg("prim")))
+        .def(init<UsdSchemaBase const&>(arg("schemaObj")))
+{% endif %}
+{% endif %}
+        .def(TfTypePythonClass())
+
+{% if not cls.isAPISchemaBase %}
+{% if cls.isMultipleApply %}
+        .def("Get",
+            ({{ cls.cppClassName }}(*)(const UsdStagePtr &stage, 
+                                       const SdfPath &path))
+               &This::Get,
+            (arg("stage"), arg("path")))
+        .def("Get",
+            ({{ cls.cppClassName }}(*)(const UsdPrim &prim,
+                                       const TfToken &name))
+               &This::Get,
+            (arg("prim"), arg("name")))
+{% else %}
+        .def("Get", &This::Get, (arg("stage"), arg("path")))
+{% endif %}
+        .staticmethod("Get")
+{% endif %}
+{% if cls.isMultipleApply %}
+
+        .def("GetAll",
+            (std::vector<{{ cls.cppClassName }}>(*)(const UsdPrim &prim))
+                &This::GetAll,
+            arg("prim"),
+            return_value_policy<TfPySequenceToList>())
+        .staticmethod("GetAll")
+{% endif %}
+{% if cls.isConcrete %}
+
+        .def("Define", &This::Define, (arg("stage"), arg("path")))
+        .staticmethod("Define")
+{% endif %}
+{% if cls.isAppliedAPISchema and not cls.isMultipleApply %}
+
+        .def("CanApply", &_WrapCanApply, (arg("prim")))
+        .staticmethod("CanApply")
+{% endif %}
+{% if cls.isAppliedAPISchema and cls.isMultipleApply %}
+
+        .def("CanApply", &_WrapCanApply, (arg("prim"), arg("name")))
+        .staticmethod("CanApply")
+{% endif %}
+{% if cls.isAppliedAPISchema and not cls.isMultipleApply %}
+
+        .def("Apply", &This::Apply, (arg("prim")))
+        .staticmethod("Apply")
+{% endif %}
+{% if cls.isAppliedAPISchema and cls.isMultipleApply %}
+
+        .def("Apply", &This::Apply, (arg("prim"), arg("name")))
+        .staticmethod("Apply")
+{% endif %}
+
+{% if cls.isMultipleApply %}
+        .def("GetSchemaAttributeNames",
+             (const TfTokenVector &(*)(bool))&This::GetSchemaAttributeNames,
+             arg("includeInherited")=true,
+             return_value_policy<TfPySequenceToList>())
+        .def("GetSchemaAttributeNames",
+             (TfTokenVector(*)(bool, const TfToken &))
+                &This::GetSchemaAttributeNames,
+             arg("includeInherited"),
+             arg("instanceName"),
+             return_value_policy<TfPySequenceToList>())
+{% else %}
+        .def("GetSchemaAttributeNames",
+             &This::GetSchemaAttributeNames,
+             arg("includeInherited")=true,
+             return_value_policy<TfPySequenceToList>())
+{% endif %}
+        .staticmethod("GetSchemaAttributeNames")
+
+        .def("_GetStaticTfType", (TfType const &(*)()) TfType::Find<This>,
+             return_value_policy<return_by_value>())
+        .staticmethod("_GetStaticTfType")
+
+        .def(!self)
+
+{% for attrName in cls.attrOrder -%}
+{% set attr = cls.attrs[attrName] %}
+{# Only emit Create/Get API if apiName is not empty string. #}
+{% if attr.apiName != '' %}
+        
+        .def("Get{{ Proper(attr.apiName) }}Attr",
+             &This::Get{{ Proper(attr.apiName) }}Attr)
+        .def("Create{{ Proper(attr.apiName) }}Attr",
+             &_Create{{ Proper(attr.apiName) }}Attr,
+             (arg("defaultValue")=object(),
+              arg("writeSparsely")=false))
+{% endif %}
+{% endfor %}
+
+{% for relName in cls.relOrder -%}
+{# Only emit Create/Get API and doxygen if apiName is not empty string. #}
+{% set rel = cls.rels[relName] %}
+{% if rel.apiName != '' %}
+        
+        .def("Get{{ Proper(rel.apiName) }}Rel",
+             &This::Get{{ Proper(rel.apiName) }}Rel)
+        .def("Create{{ Proper(rel.apiName) }}Rel",
+             &This::Create{{ Proper(rel.apiName) }}Rel)
+{% endif %}
+{% endfor %}
+{% for schema in appliedSchemas %}
+{% set schemaCls = classes[schema]%}
+{% for attrName in schemaCls.attrOrder -%}
+{% set attr = schemaCls.attrs[attrName] %}
+{# Only emit Create/Get API if apiName is not empty string. #}
+{% if attr.apiName != '' %}
+        
+        .def("Get{{ Proper(attr.apiName) }}Attr",
+             &This::Get{{ Proper(attr.apiName) }}Attr)
+        .def("Create{{ Proper(attr.apiName) }}Attr",
+             &_Create{{ Proper(attr.apiName) }}Attr,
+             (arg("defaultValue")=object(),
+              arg("writeSparsely")=false))
+{% endif %}
+{% endfor %}
+
+{% for relName in schemaCls.relOrder -%}
+{# Only emit Create/Get API and doxygen if apiName is not empty string. #}
+{% set rel = schemaCls.rels[relName] %}
+{% if rel.apiName != '' %}
+        .def("Get{{ Proper(rel.apiName) }}Rel",
+             &This::Get{{ Proper(rel.apiName) }}Rel)
+        .def("Create{{ Proper(rel.apiName) }}Rel",
+             &This::Create{{ Proper(rel.apiName) }}Rel)
+
+{% endif %}
+{% endfor %}
+        .def("{{ schema }}", &This::{{ schema }})
+{% endfor %}
+{% if cls.isMultipleApply and cls.propertyNamespace %}
+        .def("Is{{ cls.usdPrimTypeName }}Path", _WrapIs{{ cls.usdPrimTypeName }}Path)
+            .staticmethod("Is{{ cls.usdPrimTypeName }}Path")
+{% endif %}
+{% if not cls.isAPISchemaBase %}
+        .def("__repr__", ::_Repr)
+{% endif %}
+    ;
+
+    _CustomWrapCode(cls);
+}
+
+// ===================================================================== //
+// Feel free to add custom code below this line, it will be preserved by 
+// the code generator.  The entry point for your custom code should look
+// minimally like the following:
+//
+// WRAP_CUSTOM {
+//     _class
+//         .def("MyCustomMethod", ...)
+//     ;
+// }
+//
+// Of course any other ancillary or support code may be provided.
+{% if useExportAPI %}
+// 
+// Just remember to wrap code in the appropriate delimiters:
+// 'namespace {', '}'.
+//
+{% endif %}
+// ===================================================================== //
+// --(BEGIN CUSTOM CODE)--
+

package/staging_area/Blender/blender.shared/usd/usd/resources/codegenTemplates/wrapTokens.cpp

@@ -0,0 +1,25 @@
+//
+// Copyright 2016 Pixar
+//
+// Licensed under the terms set forth in the LICENSE.txt file available at
+// https://openusd.org/license.
+//
+// GENERATED FILE.  DO NOT EDIT.
+#include "pxr/external/boost/python/class.hpp"
+#include "{{ libraryPath }}/tokens.h"
+
+{% if useExportAPI %}
+{{ namespaceUsing }}
+
+{% endif %}
+#define _ADD_TOKEN(cls, name) \
+    cls.add_static_property(#name, +[]() { return {{ tokensPrefix }}Tokens->name.GetString(); });
+
+void wrap{{ tokensPrefix }}Tokens()
+{
+    pxr_boost::python::class_<{{ tokensPrefix }}TokensType, pxr_boost::python::noncopyable>
+        cls("Tokens", pxr_boost::python::no_init);
+{% for token in tokens %}
+    _ADD_TOKEN(cls, {{ token.id }});
+{% endfor %}
+}

package/staging_area/Blender/blender.shared/usd/usd/resources/generatedSchema.usda

@@ -0,0 +1,146 @@
+#usda 1.0
+(
+    "WARNING: THIS FILE IS GENERATED BY usdGenSchema.  DO NOT EDIT."
+)
+
+class "Typed" (
+    customData = {
+        string userDocBrief = '''The base class for all typed schemas (those that can impart a
+    typeName to a UsdPrim), and therefore the base class for all
+    concrete, instantiable "IsA" schemas.'''
+    }
+)
+{
+}
+
+class "APISchemaBase" (
+    customData = {
+        string userDocBrief = "The base class for all API schemas."
+    }
+)
+{
+}
+
+class "ModelAPI" (
+    customData = {
+        string userDocBrief = """UsdModelAPI is an API schema that provides an interface to a prim's
+    model qualities, if it does, in fact, represent the root prim of a model."""
+    }
+)
+{
+}
+
+class "ColorSpaceAPI" (
+    customData = {
+        string userDocBrief = """UsdColorSpaceAPI is an API schema that introduces a `colorSpace`
+    property for authoring scene referred color space opinions."""
+    }
+)
+{
+    uniform token colorSpace:name (
+        customData = {
+            string userDocBrief = """The color space that applies to attributes with
+        unauthored color spaces on this prim and its descendents."""
+        }
+    )
+}
+
+class "ColorSpaceDefinitionAPI" (
+    customData = {
+        string userDocBrief = """UsdColorSpaceDefinitionAPI is an API schema for defining a custom
+    color space."""
+    }
+)
+{
+    float2 colorSpaceDefinition:__INSTANCE_NAME__:blueChroma = (0, 0) (
+        customData = {
+            string userDocBrief = "Blue chromaticity coordinates."
+        }
+    )
+    float colorSpaceDefinition:__INSTANCE_NAME__:gamma = 1 (
+        customData = {
+            string userDocBrief = "Gamma value of the log section."
+        }
+    )
+    float2 colorSpaceDefinition:__INSTANCE_NAME__:greenChroma = (0, 1) (
+        customData = {
+            string userDocBrief = "Green chromaticity coordinates."
+        }
+    )
+    float colorSpaceDefinition:__INSTANCE_NAME__:linearBias = 0 (
+        customData = {
+            string userDocBrief = "Linear bias of the log section."
+        }
+    )
+    uniform token colorSpaceDefinition:__INSTANCE_NAME__:name = "custom" (
+        customData = {
+            string userDocBrief = "The name of the color space defined on this prim."
+        }
+    )
+    float2 colorSpaceDefinition:__INSTANCE_NAME__:redChroma = (1, 0) (
+        customData = {
+            string userDocBrief = "Red chromaticity coordinates."
+        }
+    )
+    float2 colorSpaceDefinition:__INSTANCE_NAME__:whitePoint = (0.33333334, 0.33333334) (
+        customData = {
+            string userDocBrief = "Whitepoint chromaticity coordinates."
+        }
+    )
+}
+
+class "CollectionAPI" (
+    customData = {
+        string userDocBrief = """A general purpose API schema used to describe a collection of prims
+    and properties within a scene."""
+    }
+)
+{
+    uniform opaque collection:__INSTANCE_NAME__ (
+        customData = {
+            string userDocBrief = """This property represents the collection for the purpose of 
+        allowing another collection to include it."""
+        }
+    )
+    rel collection:__INSTANCE_NAME__:excludes (
+        customData = {
+            string userDocBrief = """Specifies a list of targets that are excluded below
+        the included paths in this collection."""
+        }
+    )
+    uniform token collection:__INSTANCE_NAME__:expansionRule = "expandPrims" (
+        allowedTokens = ["explicitOnly", "expandPrims", "expandPrimsAndProperties"]
+        customData = {
+            string userDocBrief = """Specifies how the paths that are included in
+        the collection must be expanded to determine its members."""
+        }
+    )
+    uniform bool collection:__INSTANCE_NAME__:includeRoot (
+        customData = {
+            string userDocBrief = """Boolean attribute indicating whether the pseudo-root
+        path `</>` should be counted as one of the included target
+        paths."""
+        }
+    )
+    rel collection:__INSTANCE_NAME__:includes (
+        customData = {
+            string userDocBrief = "Specifies a list of targets that are included in the collection."
+        }
+    )
+    uniform pathExpression collection:__INSTANCE_NAME__:membershipExpression (
+        customData = {
+            string userDocBrief = """Specifies a path expression that determines membership in this
+        collection."""
+        }
+    )
+}
+
+class "ClipsAPI" (
+    customData = {
+        string userDocBrief = """UsdClipsAPI is an API schema that provides an interface to
+    a prim's clip metadata."""
+    }
+)
+{
+}
+

package/staging_area/Blender/blender.shared/usd/usd/resources/plugInfo.json

@@ -0,0 +1,125 @@
+# Portions of this file auto-generated by usdGenSchema.
+# Edits will survive regeneration except for comments and
+# changes to types with autoGenerated=true.
+{
+    "Plugins": [
+        {
+            "Info": {
+                "SdfMetadata": {
+                    "apiSchemas": {
+                        "appliesTo": "prims", 
+                        "type": "tokenlistop"
+                    }, 
+                    "clipSets": {
+                        "appliesTo": [
+                            "prims"
+                        ], 
+                        "type": "stringlistop"
+                    }, 
+                    "clips": {
+                        "appliesTo": [
+                            "prims"
+                        ], 
+                        "type": "dictionary"
+                    }, 
+                    "fallbackPrimTypes": {
+                        "appliesTo": [
+                            "layers"
+                        ], 
+                        "type": "dictionary"
+                    }
+                }, 
+                "Types": {
+                    "UsdAPISchemaBase": {
+                        "alias": {
+                            "UsdSchemaBase": "APISchemaBase"
+                        }, 
+                        "autoGenerated": true, 
+                        "bases": [
+                            "UsdSchemaBase"
+                        ], 
+                        "schemaIdentifier": "APISchemaBase", 
+                        "schemaKind": "abstractBase"
+                    }, 
+                    "UsdClipsAPI": {
+                        "alias": {
+                            "UsdSchemaBase": "ClipsAPI"
+                        }, 
+                        "autoGenerated": true, 
+                        "bases": [
+                            "UsdAPISchemaBase"
+                        ], 
+                        "schemaIdentifier": "ClipsAPI", 
+                        "schemaKind": "nonAppliedAPI"
+                    }, 
+                    "UsdCollectionAPI": {
+                        "alias": {
+                            "UsdSchemaBase": "CollectionAPI"
+                        }, 
+                        "autoGenerated": true, 
+                        "bases": [
+                            "UsdAPISchemaBase"
+                        ], 
+                        "schemaIdentifier": "CollectionAPI", 
+                        "schemaKind": "multipleApplyAPI"
+                    }, 
+                    "UsdColorSpaceAPI": {
+                        "alias": {
+                            "UsdSchemaBase": "ColorSpaceAPI"
+                        }, 
+                        "autoGenerated": true, 
+                        "bases": [
+                            "UsdAPISchemaBase"
+                        ], 
+                        "schemaIdentifier": "ColorSpaceAPI", 
+                        "schemaKind": "singleApplyAPI"
+                    }, 
+                    "UsdColorSpaceDefinitionAPI": {
+                        "alias": {
+                            "UsdSchemaBase": "ColorSpaceDefinitionAPI"
+                        }, 
+                        "autoGenerated": true, 
+                        "bases": [
+                            "UsdAPISchemaBase"
+                        ], 
+                        "schemaIdentifier": "ColorSpaceDefinitionAPI", 
+                        "schemaKind": "multipleApplyAPI"
+                    }, 
+                    "UsdModelAPI": {
+                        "alias": {
+                            "UsdSchemaBase": "ModelAPI"
+                        }, 
+                        "autoGenerated": true, 
+                        "bases": [
+                            "UsdAPISchemaBase"
+                        ], 
+                        "schemaIdentifier": "ModelAPI", 
+                        "schemaKind": "nonAppliedAPI"
+                    }, 
+                    "UsdSchemaBase": {
+                        "alias": {
+                            "UsdSchemaBase": "SchemaBase"
+                        }, 
+                        "schemaKind": "abstractBase"
+                    }, 
+                    "UsdTyped": {
+                        "alias": {
+                            "UsdSchemaBase": "Typed"
+                        }, 
+                        "autoGenerated": true, 
+                        "bases": [
+                            "UsdSchemaBase"
+                        ], 
+                        "schemaIdentifier": "Typed", 
+                        "schemaKind": "abstractBase"
+                    }
+                }
+            }, 
+            "LibraryPath": "", 
+            "Name": "usd", 
+            "ResourcePath": "resources", 
+            "Root": "..", 
+            "Type": "library"
+        }
+    ]
+}