HDK
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
limitAPI.h
Go to the documentation of this file.
1 //
2 // Copyright 2016 Pixar
3 //
4 // Licensed under the Apache License, Version 2.0 (the "Apache License")
5 // with the following modification; you may not use this file except in
6 // compliance with the Apache License and the following modification to it:
7 // Section 6. Trademarks. is deleted and replaced with:
8 //
9 // 6. Trademarks. This License does not grant permission to use the trade
10 // names, trademarks, service marks, or product names of the Licensor
11 // and its affiliates, except as required to comply with Section 4(c) of
12 // the License and to reproduce the content of the NOTICE file.
13 //
14 // You may obtain a copy of the Apache License at
15 //
16 // http://www.apache.org/licenses/LICENSE-2.0
17 //
18 // Unless required by applicable law or agreed to in writing, software
19 // distributed under the Apache License with the above modification is
20 // distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
21 // KIND, either express or implied. See the Apache License for the specific
22 // language governing permissions and limitations under the Apache License.
23 //
24 #ifndef USDPHYSICS_GENERATED_LIMITAPI_H
25 #define USDPHYSICS_GENERATED_LIMITAPI_H
26 
27 /// \file usdPhysics/limitAPI.h
28 
29 #include "pxr/pxr.h"
30 #include "pxr/usd/usdPhysics/api.h"
32 #include "pxr/usd/usd/prim.h"
33 #include "pxr/usd/usd/stage.h"
35 
36 #include "pxr/base/vt/value.h"
37 
38 #include "pxr/base/gf/vec3d.h"
39 #include "pxr/base/gf/vec3f.h"
40 #include "pxr/base/gf/matrix4d.h"
41 
42 #include "pxr/base/tf/token.h"
43 #include "pxr/base/tf/type.h"
44 
46 
47 class SdfAssetPath;
48 
49 // -------------------------------------------------------------------------- //
50 // PHYSICSLIMITAPI //
51 // -------------------------------------------------------------------------- //
52 
53 /// \class UsdPhysicsLimitAPI
54 ///
55 /// The PhysicsLimitAPI can be applied to a PhysicsJoint and will
56 /// restrict the movement along an axis. PhysicsLimitAPI is a multipleApply
57 /// schema: The PhysicsJoint can be restricted along "transX", "transY",
58 /// "transZ", "rotX", "rotY", "rotZ", "distance". Setting these as a
59 /// multipleApply schema TfToken name will define the degree of freedom the
60 /// PhysicsLimitAPI is applied to. Note that if the low limit is higher than
61 /// the high limit, motion along this axis is considered locked.
62 ///
64 {
65 public:
66  /// Compile time constant representing what kind of schema this class is.
67  ///
68  /// \sa UsdSchemaKind
70 
71  /// Construct a UsdPhysicsLimitAPI on UsdPrim \p prim with
72  /// name \p name . Equivalent to
73  /// UsdPhysicsLimitAPI::Get(
74  /// prim.GetStage(),
75  /// prim.GetPath().AppendProperty(
76  /// "limit:name"));
77  ///
78  /// for a \em valid \p prim, but will not immediately throw an error for
79  /// an invalid \p prim
81  const UsdPrim& prim=UsdPrim(), const TfToken &name=TfToken())
82  : UsdAPISchemaBase(prim, /*instanceName*/ name)
83  { }
84 
85  /// Construct a UsdPhysicsLimitAPI on the prim held by \p schemaObj with
86  /// name \p name. Should be preferred over
87  /// UsdPhysicsLimitAPI(schemaObj.GetPrim(), name), as it preserves
88  /// SchemaBase state.
90  const UsdSchemaBase& schemaObj, const TfToken &name)
91  : UsdAPISchemaBase(schemaObj, /*instanceName*/ name)
92  { }
93 
94  /// Destructor.
96  virtual ~UsdPhysicsLimitAPI();
97 
98  /// Return a vector of names of all pre-declared attributes for this schema
99  /// class and all its ancestor classes. Does not include attributes that
100  /// may be authored by custom/extended methods of the schemas involved.
102  static const TfTokenVector &
103  GetSchemaAttributeNames(bool includeInherited=true);
104 
105  /// Return a vector of names of all pre-declared attributes for this schema
106  /// class and all its ancestor classes for a given instance name. Does not
107  /// include attributes that may be authored by custom/extended methods of
108  /// the schemas involved. The names returned will have the proper namespace
109  /// prefix.
111  static TfTokenVector
112  GetSchemaAttributeNames(bool includeInherited, const TfToken &instanceName);
113 
114  /// Returns the name of this multiple-apply schema instance
115  TfToken GetName() const {
116  return _GetInstanceName();
117  }
118 
119  /// Return a UsdPhysicsLimitAPI holding the prim adhering to this
120  /// schema at \p path on \p stage. If no prim exists at \p path on
121  /// \p stage, or if the prim at that path does not adhere to this schema,
122  /// return an invalid schema object. \p path must be of the format
123  /// <path>.limit:name .
124  ///
125  /// This is shorthand for the following:
126  ///
127  /// \code
128  /// TfToken name = SdfPath::StripNamespace(path.GetToken());
129  /// UsdPhysicsLimitAPI(
130  /// stage->GetPrimAtPath(path.GetPrimPath()), name);
131  /// \endcode
132  ///
134  static UsdPhysicsLimitAPI
135  Get(const UsdStagePtr &stage, const SdfPath &path);
136 
137  /// Return a UsdPhysicsLimitAPI with name \p name holding the
138  /// prim \p prim. Shorthand for UsdPhysicsLimitAPI(prim, name);
140  static UsdPhysicsLimitAPI
141  Get(const UsdPrim &prim, const TfToken &name);
142 
143  /// Return a vector of all named instances of UsdPhysicsLimitAPI on the
144  /// given \p prim.
146  static std::vector<UsdPhysicsLimitAPI>
147  GetAll(const UsdPrim &prim);
148 
149  /// Checks if the given name \p baseName is the base name of a property
150  /// of PhysicsLimitAPI.
152  static bool
153  IsSchemaPropertyBaseName(const TfToken &baseName);
154 
155  /// Checks if the given path \p path is of an API schema of type
156  /// PhysicsLimitAPI. If so, it stores the instance name of
157  /// the schema in \p name and returns true. Otherwise, it returns false.
159  static bool
161 
162  /// Returns true if this <b>multiple-apply</b> API schema can be applied,
163  /// with the given instance name, \p name, to the given \p prim. If this
164  /// schema can not be a applied the prim, this returns false and, if
165  /// provided, populates \p whyNot with the reason it can not be applied.
166  ///
167  /// Note that if CanApply returns false, that does not necessarily imply
168  /// that calling Apply will fail. Callers are expected to call CanApply
169  /// before calling Apply if they want to ensure that it is valid to
170  /// apply a schema.
171  ///
172  /// \sa UsdPrim::GetAppliedSchemas()
173  /// \sa UsdPrim::HasAPI()
174  /// \sa UsdPrim::CanApplyAPI()
175  /// \sa UsdPrim::ApplyAPI()
176  /// \sa UsdPrim::RemoveAPI()
177  ///
179  static bool
180  CanApply(const UsdPrim &prim, const TfToken &name,
181  std::string *whyNot=nullptr);
182 
183  /// Applies this <b>multiple-apply</b> API schema to the given \p prim
184  /// along with the given instance name, \p name.
185  ///
186  /// This information is stored by adding "PhysicsLimitAPI:<i>name</i>"
187  /// to the token-valued, listOp metadata \em apiSchemas on the prim.
188  /// For example, if \p name is 'instance1', the token
189  /// 'PhysicsLimitAPI:instance1' is added to 'apiSchemas'.
190  ///
191  /// \return A valid UsdPhysicsLimitAPI object is returned upon success.
192  /// An invalid (or empty) UsdPhysicsLimitAPI object is returned upon
193  /// failure. See \ref UsdPrim::ApplyAPI() for
194  /// conditions resulting in failure.
195  ///
196  /// \sa UsdPrim::GetAppliedSchemas()
197  /// \sa UsdPrim::HasAPI()
198  /// \sa UsdPrim::CanApplyAPI()
199  /// \sa UsdPrim::ApplyAPI()
200  /// \sa UsdPrim::RemoveAPI()
201  ///
203  static UsdPhysicsLimitAPI
204  Apply(const UsdPrim &prim, const TfToken &name);
205 
206 protected:
207  /// Returns the kind of schema this class belongs to.
208  ///
209  /// \sa UsdSchemaKind
211  UsdSchemaKind _GetSchemaKind() const override;
212 
213 private:
214  // needs to invoke _GetStaticTfType.
215  friend class UsdSchemaRegistry;
217  static const TfType &_GetStaticTfType();
218 
219  static bool _IsTypedSchema();
220 
221  // override SchemaBase virtuals.
223  const TfType &_GetTfType() const override;
224 
225 public:
226  // --------------------------------------------------------------------- //
227  // LOW
228  // --------------------------------------------------------------------- //
229  /// Lower limit. Units: degrees or distance depending on trans or
230  /// rot axis applied to. -inf means not limited in negative direction.
231  ///
232  /// | ||
233  /// | -- | -- |
234  /// | Declaration | `float physics:low = -inf` |
235  /// | C++ Type | float |
236  /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Float |
238  UsdAttribute GetLowAttr() const;
239 
240  /// See GetLowAttr(), and also
241  /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create.
242  /// If specified, author \p defaultValue as the attribute's default,
243  /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true -
244  /// the default for \p writeSparsely is \c false.
246  UsdAttribute CreateLowAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const;
247 
248 public:
249  // --------------------------------------------------------------------- //
250  // HIGH
251  // --------------------------------------------------------------------- //
252  /// Upper limit. Units: degrees or distance depending on trans or
253  /// rot axis applied to. inf means not limited in positive direction.
254  ///
255  /// | ||
256  /// | -- | -- |
257  /// | Declaration | `float physics:high = inf` |
258  /// | C++ Type | float |
259  /// | \ref Usd_Datatypes "Usd Type" | SdfValueTypeNames->Float |
261  UsdAttribute GetHighAttr() const;
262 
263  /// See GetHighAttr(), and also
264  /// \ref Usd_Create_Or_Get_Property for when to use Get vs Create.
265  /// If specified, author \p defaultValue as the attribute's default,
266  /// sparsely (when it makes sense to do so) if \p writeSparsely is \c true -
267  /// the default for \p writeSparsely is \c false.
269  UsdAttribute CreateHighAttr(VtValue const &defaultValue = VtValue(), bool writeSparsely=false) const;
270 
271 public:
272  // ===================================================================== //
273  // Feel free to add custom code below this line, it will be preserved by
274  // the code generator.
275  //
276  // Just remember to:
277  // - Close the class declaration with };
278  // - Close the namespace with PXR_NAMESPACE_CLOSE_SCOPE
279  // - Close the include guard with #endif
280  // ===================================================================== //
281  // --(BEGIN CUSTOM CODE)--
282 };
283 
285 
286 #endif
static USDPHYSICS_API UsdPhysicsLimitAPI Apply(const UsdPrim &prim, const TfToken &name)
static USDPHYSICS_API const TfTokenVector & GetSchemaAttributeNames(bool includeInherited=true)
USDPHYSICS_API UsdAttribute GetHighAttr() const
static USDPHYSICS_API std::vector< UsdPhysicsLimitAPI > GetAll(const UsdPrim &prim)
USDPHYSICS_API UsdAttribute GetLowAttr() const
GLsizei const GLchar *const * string
Definition: glcorearb.h:814
GLsizei const GLchar *const * path
Definition: glcorearb.h:3341
static USDPHYSICS_API UsdPhysicsLimitAPI Get(const UsdStagePtr &stage, const SdfPath &path)
static USDPHYSICS_API bool IsPhysicsLimitAPIPath(const SdfPath &path, TfToken *name)
const TfToken & _GetInstanceName() const
Definition: token.h:87
USDPHYSICS_API UsdAttribute CreateHighAttr(VtValue const &defaultValue=VtValue(), bool writeSparsely=false) const
static USDPHYSICS_API bool IsSchemaPropertyBaseName(const TfToken &baseName)
Definition: prim.h:133
UsdPhysicsLimitAPI(const UsdSchemaBase &schemaObj, const TfToken &name)
Definition: limitAPI.h:89
std::vector< TfToken > TfTokenVector
Convenience types.
Definition: token.h:457
static USDPHYSICS_API bool CanApply(const UsdPrim &prim, const TfToken &name, std::string *whyNot=nullptr)
static const UsdSchemaKind schemaKind
Definition: limitAPI.h:69
GLuint const GLchar * name
Definition: glcorearb.h:786
Definition: path.h:290
USDPHYSICS_API UsdSchemaKind _GetSchemaKind() const override
#define USDPHYSICS_API
Definition: api.h:40
TfToken GetName() const
Returns the name of this multiple-apply schema instance.
Definition: limitAPI.h:115
UsdPhysicsLimitAPI(const UsdPrim &prim=UsdPrim(), const TfToken &name=TfToken())
Definition: limitAPI.h:80
UsdSchemaKind
Definition: common.h:129
virtual USDPHYSICS_API ~UsdPhysicsLimitAPI()
Destructor.
PXR_NAMESPACE_CLOSE_SCOPE PXR_NAMESPACE_OPEN_SCOPE
Definition: path.h:1432
#define PXR_NAMESPACE_CLOSE_SCOPE
Definition: pxr.h:91
Definition: type.h:64
USDPHYSICS_API UsdAttribute CreateLowAttr(VtValue const &defaultValue=VtValue(), bool writeSparsely=false) const
Definition: value.h:164
Multiple Apply API Schema.