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 #include "pxr/usd/usdContrived/base.h"
25 #include "pxr/usd/usd/schemaBase.h"
26
27 #include "pxr/usd/sdf/primSpec.h"
28
29 #include "pxr/usd/usd/pyConversions.h"
30 #include "pxr/base/tf/pyContainerConversions.h"
31 #include "pxr/base/tf/pyResultConversions.h"
32 #include "pxr/base/tf/pyUtils.h"
33 #include "pxr/base/tf/wrapTypeHelpers.h"
34
35 #include <boost/python.hpp>
36
37 #include <string>
38
39 using namespace boost::python;
40
41 using namespace foo::bar::baz;
42
43 namespace {
44
45 #define WRAP_CUSTOM \
46 template <class Cls> static void _CustomWrapCode(Cls &_class)
47
48 // fwd decl.
49 WRAP_CUSTOM;
50
51
52 static UsdAttribute
_CreateMyVaryingTokenAttr(UsdContrivedBase & self,object defaultVal,bool writeSparsely)53 _CreateMyVaryingTokenAttr(UsdContrivedBase &self,
54 object defaultVal, bool writeSparsely) {
55 return self.CreateMyVaryingTokenAttr(
56 UsdPythonToSdfType(defaultVal, SdfValueTypeNames->Token), writeSparsely);
57 }
58
59 static UsdAttribute
_CreateMyVaryingTokenArrayAttr(UsdContrivedBase & self,object defaultVal,bool writeSparsely)60 _CreateMyVaryingTokenArrayAttr(UsdContrivedBase &self,
61 object defaultVal, bool writeSparsely) {
62 return self.CreateMyVaryingTokenArrayAttr(
63 UsdPythonToSdfType(defaultVal, SdfValueTypeNames->TokenArray), writeSparsely);
64 }
65
66 static UsdAttribute
_CreateMyUniformBoolAttr(UsdContrivedBase & self,object defaultVal,bool writeSparsely)67 _CreateMyUniformBoolAttr(UsdContrivedBase &self,
68 object defaultVal, bool writeSparsely) {
69 return self.CreateMyUniformBoolAttr(
70 UsdPythonToSdfType(defaultVal, SdfValueTypeNames->Bool), writeSparsely);
71 }
72
73 static UsdAttribute
_CreateMyDoubleAttr(UsdContrivedBase & self,object defaultVal,bool writeSparsely)74 _CreateMyDoubleAttr(UsdContrivedBase &self,
75 object defaultVal, bool writeSparsely) {
76 return self.CreateMyDoubleAttr(
77 UsdPythonToSdfType(defaultVal, SdfValueTypeNames->Double), writeSparsely);
78 }
79
80 static UsdAttribute
_CreateBoolAttr(UsdContrivedBase & self,object defaultVal,bool writeSparsely)81 _CreateBoolAttr(UsdContrivedBase &self,
82 object defaultVal, bool writeSparsely) {
83 return self.CreateBoolAttr(
84 UsdPythonToSdfType(defaultVal, SdfValueTypeNames->Bool), writeSparsely);
85 }
86
87 static UsdAttribute
_CreateUcharAttr(UsdContrivedBase & self,object defaultVal,bool writeSparsely)88 _CreateUcharAttr(UsdContrivedBase &self,
89 object defaultVal, bool writeSparsely) {
90 return self.CreateUcharAttr(
91 UsdPythonToSdfType(defaultVal, SdfValueTypeNames->UChar), writeSparsely);
92 }
93
94 static UsdAttribute
_CreateIntAttr(UsdContrivedBase & self,object defaultVal,bool writeSparsely)95 _CreateIntAttr(UsdContrivedBase &self,
96 object defaultVal, bool writeSparsely) {
97 return self.CreateIntAttr(
98 UsdPythonToSdfType(defaultVal, SdfValueTypeNames->Int), writeSparsely);
99 }
100
101 static UsdAttribute
_CreateUintAttr(UsdContrivedBase & self,object defaultVal,bool writeSparsely)102 _CreateUintAttr(UsdContrivedBase &self,
103 object defaultVal, bool writeSparsely) {
104 return self.CreateUintAttr(
105 UsdPythonToSdfType(defaultVal, SdfValueTypeNames->UInt), writeSparsely);
106 }
107
108 static UsdAttribute
_CreateInt64Attr(UsdContrivedBase & self,object defaultVal,bool writeSparsely)109 _CreateInt64Attr(UsdContrivedBase &self,
110 object defaultVal, bool writeSparsely) {
111 return self.CreateInt64Attr(
112 UsdPythonToSdfType(defaultVal, SdfValueTypeNames->Int64), writeSparsely);
113 }
114
115 static UsdAttribute
_CreateUint64Attr(UsdContrivedBase & self,object defaultVal,bool writeSparsely)116 _CreateUint64Attr(UsdContrivedBase &self,
117 object defaultVal, bool writeSparsely) {
118 return self.CreateUint64Attr(
119 UsdPythonToSdfType(defaultVal, SdfValueTypeNames->UInt64), writeSparsely);
120 }
121
122 static UsdAttribute
_CreateHalfAttr(UsdContrivedBase & self,object defaultVal,bool writeSparsely)123 _CreateHalfAttr(UsdContrivedBase &self,
124 object defaultVal, bool writeSparsely) {
125 return self.CreateHalfAttr(
126 UsdPythonToSdfType(defaultVal, SdfValueTypeNames->Half), writeSparsely);
127 }
128
129 static UsdAttribute
_CreateFloatAttr(UsdContrivedBase & self,object defaultVal,bool writeSparsely)130 _CreateFloatAttr(UsdContrivedBase &self,
131 object defaultVal, bool writeSparsely) {
132 return self.CreateFloatAttr(
133 UsdPythonToSdfType(defaultVal, SdfValueTypeNames->Float), writeSparsely);
134 }
135
136 static UsdAttribute
_CreateDoubleAttr(UsdContrivedBase & self,object defaultVal,bool writeSparsely)137 _CreateDoubleAttr(UsdContrivedBase &self,
138 object defaultVal, bool writeSparsely) {
139 return self.CreateDoubleAttr(
140 UsdPythonToSdfType(defaultVal, SdfValueTypeNames->Double), writeSparsely);
141 }
142
143 static UsdAttribute
_CreateStringAttr(UsdContrivedBase & self,object defaultVal,bool writeSparsely)144 _CreateStringAttr(UsdContrivedBase &self,
145 object defaultVal, bool writeSparsely) {
146 return self.CreateStringAttr(
147 UsdPythonToSdfType(defaultVal, SdfValueTypeNames->String), writeSparsely);
148 }
149
150 static UsdAttribute
_CreateTokenAttr(UsdContrivedBase & self,object defaultVal,bool writeSparsely)151 _CreateTokenAttr(UsdContrivedBase &self,
152 object defaultVal, bool writeSparsely) {
153 return self.CreateTokenAttr(
154 UsdPythonToSdfType(defaultVal, SdfValueTypeNames->Token), writeSparsely);
155 }
156
157 static UsdAttribute
_CreateAssetAttr(UsdContrivedBase & self,object defaultVal,bool writeSparsely)158 _CreateAssetAttr(UsdContrivedBase &self,
159 object defaultVal, bool writeSparsely) {
160 return self.CreateAssetAttr(
161 UsdPythonToSdfType(defaultVal, SdfValueTypeNames->Asset), writeSparsely);
162 }
163
164 static UsdAttribute
_CreateInt2Attr(UsdContrivedBase & self,object defaultVal,bool writeSparsely)165 _CreateInt2Attr(UsdContrivedBase &self,
166 object defaultVal, bool writeSparsely) {
167 return self.CreateInt2Attr(
168 UsdPythonToSdfType(defaultVal, SdfValueTypeNames->Int2), writeSparsely);
169 }
170
171 static UsdAttribute
_CreateInt3Attr(UsdContrivedBase & self,object defaultVal,bool writeSparsely)172 _CreateInt3Attr(UsdContrivedBase &self,
173 object defaultVal, bool writeSparsely) {
174 return self.CreateInt3Attr(
175 UsdPythonToSdfType(defaultVal, SdfValueTypeNames->Int3), writeSparsely);
176 }
177
178 static UsdAttribute
_CreateInt4Attr(UsdContrivedBase & self,object defaultVal,bool writeSparsely)179 _CreateInt4Attr(UsdContrivedBase &self,
180 object defaultVal, bool writeSparsely) {
181 return self.CreateInt4Attr(
182 UsdPythonToSdfType(defaultVal, SdfValueTypeNames->Int4), writeSparsely);
183 }
184
185 static UsdAttribute
_CreateHalf2Attr(UsdContrivedBase & self,object defaultVal,bool writeSparsely)186 _CreateHalf2Attr(UsdContrivedBase &self,
187 object defaultVal, bool writeSparsely) {
188 return self.CreateHalf2Attr(
189 UsdPythonToSdfType(defaultVal, SdfValueTypeNames->Half2), writeSparsely);
190 }
191
192 static UsdAttribute
_CreateHalf3Attr(UsdContrivedBase & self,object defaultVal,bool writeSparsely)193 _CreateHalf3Attr(UsdContrivedBase &self,
194 object defaultVal, bool writeSparsely) {
195 return self.CreateHalf3Attr(
196 UsdPythonToSdfType(defaultVal, SdfValueTypeNames->Half3), writeSparsely);
197 }
198
199 static UsdAttribute
_CreateHalf4Attr(UsdContrivedBase & self,object defaultVal,bool writeSparsely)200 _CreateHalf4Attr(UsdContrivedBase &self,
201 object defaultVal, bool writeSparsely) {
202 return self.CreateHalf4Attr(
203 UsdPythonToSdfType(defaultVal, SdfValueTypeNames->Half4), writeSparsely);
204 }
205
206 static UsdAttribute
_CreateFloat2Attr(UsdContrivedBase & self,object defaultVal,bool writeSparsely)207 _CreateFloat2Attr(UsdContrivedBase &self,
208 object defaultVal, bool writeSparsely) {
209 return self.CreateFloat2Attr(
210 UsdPythonToSdfType(defaultVal, SdfValueTypeNames->Float2), writeSparsely);
211 }
212
213 static UsdAttribute
_CreateFloat3Attr(UsdContrivedBase & self,object defaultVal,bool writeSparsely)214 _CreateFloat3Attr(UsdContrivedBase &self,
215 object defaultVal, bool writeSparsely) {
216 return self.CreateFloat3Attr(
217 UsdPythonToSdfType(defaultVal, SdfValueTypeNames->Float3), writeSparsely);
218 }
219
220 static UsdAttribute
_CreateFloat4Attr(UsdContrivedBase & self,object defaultVal,bool writeSparsely)221 _CreateFloat4Attr(UsdContrivedBase &self,
222 object defaultVal, bool writeSparsely) {
223 return self.CreateFloat4Attr(
224 UsdPythonToSdfType(defaultVal, SdfValueTypeNames->Float4), writeSparsely);
225 }
226
227 static UsdAttribute
_CreateDouble2Attr(UsdContrivedBase & self,object defaultVal,bool writeSparsely)228 _CreateDouble2Attr(UsdContrivedBase &self,
229 object defaultVal, bool writeSparsely) {
230 return self.CreateDouble2Attr(
231 UsdPythonToSdfType(defaultVal, SdfValueTypeNames->Double2), writeSparsely);
232 }
233
234 static UsdAttribute
_CreateDouble3Attr(UsdContrivedBase & self,object defaultVal,bool writeSparsely)235 _CreateDouble3Attr(UsdContrivedBase &self,
236 object defaultVal, bool writeSparsely) {
237 return self.CreateDouble3Attr(
238 UsdPythonToSdfType(defaultVal, SdfValueTypeNames->Double3), writeSparsely);
239 }
240
241 static UsdAttribute
_CreateDouble4Attr(UsdContrivedBase & self,object defaultVal,bool writeSparsely)242 _CreateDouble4Attr(UsdContrivedBase &self,
243 object defaultVal, bool writeSparsely) {
244 return self.CreateDouble4Attr(
245 UsdPythonToSdfType(defaultVal, SdfValueTypeNames->Double4), writeSparsely);
246 }
247
248 static UsdAttribute
_CreatePoint3hAttr(UsdContrivedBase & self,object defaultVal,bool writeSparsely)249 _CreatePoint3hAttr(UsdContrivedBase &self,
250 object defaultVal, bool writeSparsely) {
251 return self.CreatePoint3hAttr(
252 UsdPythonToSdfType(defaultVal, SdfValueTypeNames->Point3h), writeSparsely);
253 }
254
255 static UsdAttribute
_CreatePoint3fAttr(UsdContrivedBase & self,object defaultVal,bool writeSparsely)256 _CreatePoint3fAttr(UsdContrivedBase &self,
257 object defaultVal, bool writeSparsely) {
258 return self.CreatePoint3fAttr(
259 UsdPythonToSdfType(defaultVal, SdfValueTypeNames->Point3f), writeSparsely);
260 }
261
262 static UsdAttribute
_CreatePoint3dAttr(UsdContrivedBase & self,object defaultVal,bool writeSparsely)263 _CreatePoint3dAttr(UsdContrivedBase &self,
264 object defaultVal, bool writeSparsely) {
265 return self.CreatePoint3dAttr(
266 UsdPythonToSdfType(defaultVal, SdfValueTypeNames->Point3d), writeSparsely);
267 }
268
269 static UsdAttribute
_CreateVector3dAttr(UsdContrivedBase & self,object defaultVal,bool writeSparsely)270 _CreateVector3dAttr(UsdContrivedBase &self,
271 object defaultVal, bool writeSparsely) {
272 return self.CreateVector3dAttr(
273 UsdPythonToSdfType(defaultVal, SdfValueTypeNames->Vector3d), writeSparsely);
274 }
275
276 static UsdAttribute
_CreateVector3fAttr(UsdContrivedBase & self,object defaultVal,bool writeSparsely)277 _CreateVector3fAttr(UsdContrivedBase &self,
278 object defaultVal, bool writeSparsely) {
279 return self.CreateVector3fAttr(
280 UsdPythonToSdfType(defaultVal, SdfValueTypeNames->Vector3f), writeSparsely);
281 }
282
283 static UsdAttribute
_CreateVector3hAttr(UsdContrivedBase & self,object defaultVal,bool writeSparsely)284 _CreateVector3hAttr(UsdContrivedBase &self,
285 object defaultVal, bool writeSparsely) {
286 return self.CreateVector3hAttr(
287 UsdPythonToSdfType(defaultVal, SdfValueTypeNames->Vector3h), writeSparsely);
288 }
289
290 static UsdAttribute
_CreateNormal3dAttr(UsdContrivedBase & self,object defaultVal,bool writeSparsely)291 _CreateNormal3dAttr(UsdContrivedBase &self,
292 object defaultVal, bool writeSparsely) {
293 return self.CreateNormal3dAttr(
294 UsdPythonToSdfType(defaultVal, SdfValueTypeNames->Normal3d), writeSparsely);
295 }
296
297 static UsdAttribute
_CreateNormal3fAttr(UsdContrivedBase & self,object defaultVal,bool writeSparsely)298 _CreateNormal3fAttr(UsdContrivedBase &self,
299 object defaultVal, bool writeSparsely) {
300 return self.CreateNormal3fAttr(
301 UsdPythonToSdfType(defaultVal, SdfValueTypeNames->Normal3f), writeSparsely);
302 }
303
304 static UsdAttribute
_CreateNormal3hAttr(UsdContrivedBase & self,object defaultVal,bool writeSparsely)305 _CreateNormal3hAttr(UsdContrivedBase &self,
306 object defaultVal, bool writeSparsely) {
307 return self.CreateNormal3hAttr(
308 UsdPythonToSdfType(defaultVal, SdfValueTypeNames->Normal3h), writeSparsely);
309 }
310
311 static UsdAttribute
_CreateColor3dAttr(UsdContrivedBase & self,object defaultVal,bool writeSparsely)312 _CreateColor3dAttr(UsdContrivedBase &self,
313 object defaultVal, bool writeSparsely) {
314 return self.CreateColor3dAttr(
315 UsdPythonToSdfType(defaultVal, SdfValueTypeNames->Color3d), writeSparsely);
316 }
317
318 static UsdAttribute
_CreateColor3fAttr(UsdContrivedBase & self,object defaultVal,bool writeSparsely)319 _CreateColor3fAttr(UsdContrivedBase &self,
320 object defaultVal, bool writeSparsely) {
321 return self.CreateColor3fAttr(
322 UsdPythonToSdfType(defaultVal, SdfValueTypeNames->Color3f), writeSparsely);
323 }
324
325 static UsdAttribute
_CreateColor3hAttr(UsdContrivedBase & self,object defaultVal,bool writeSparsely)326 _CreateColor3hAttr(UsdContrivedBase &self,
327 object defaultVal, bool writeSparsely) {
328 return self.CreateColor3hAttr(
329 UsdPythonToSdfType(defaultVal, SdfValueTypeNames->Color3h), writeSparsely);
330 }
331
332 static UsdAttribute
_CreateColor4dAttr(UsdContrivedBase & self,object defaultVal,bool writeSparsely)333 _CreateColor4dAttr(UsdContrivedBase &self,
334 object defaultVal, bool writeSparsely) {
335 return self.CreateColor4dAttr(
336 UsdPythonToSdfType(defaultVal, SdfValueTypeNames->Color4d), writeSparsely);
337 }
338
339 static UsdAttribute
_CreateColor4fAttr(UsdContrivedBase & self,object defaultVal,bool writeSparsely)340 _CreateColor4fAttr(UsdContrivedBase &self,
341 object defaultVal, bool writeSparsely) {
342 return self.CreateColor4fAttr(
343 UsdPythonToSdfType(defaultVal, SdfValueTypeNames->Color4f), writeSparsely);
344 }
345
346 static UsdAttribute
_CreateColor4hAttr(UsdContrivedBase & self,object defaultVal,bool writeSparsely)347 _CreateColor4hAttr(UsdContrivedBase &self,
348 object defaultVal, bool writeSparsely) {
349 return self.CreateColor4hAttr(
350 UsdPythonToSdfType(defaultVal, SdfValueTypeNames->Color4h), writeSparsely);
351 }
352
353 static UsdAttribute
_CreateQuatdAttr(UsdContrivedBase & self,object defaultVal,bool writeSparsely)354 _CreateQuatdAttr(UsdContrivedBase &self,
355 object defaultVal, bool writeSparsely) {
356 return self.CreateQuatdAttr(
357 UsdPythonToSdfType(defaultVal, SdfValueTypeNames->Quatd), writeSparsely);
358 }
359
360 static UsdAttribute
_CreateQuatfAttr(UsdContrivedBase & self,object defaultVal,bool writeSparsely)361 _CreateQuatfAttr(UsdContrivedBase &self,
362 object defaultVal, bool writeSparsely) {
363 return self.CreateQuatfAttr(
364 UsdPythonToSdfType(defaultVal, SdfValueTypeNames->Quatf), writeSparsely);
365 }
366
367 static UsdAttribute
_CreateQuathAttr(UsdContrivedBase & self,object defaultVal,bool writeSparsely)368 _CreateQuathAttr(UsdContrivedBase &self,
369 object defaultVal, bool writeSparsely) {
370 return self.CreateQuathAttr(
371 UsdPythonToSdfType(defaultVal, SdfValueTypeNames->Quath), writeSparsely);
372 }
373
374 static UsdAttribute
_CreateMatrix2dAttr(UsdContrivedBase & self,object defaultVal,bool writeSparsely)375 _CreateMatrix2dAttr(UsdContrivedBase &self,
376 object defaultVal, bool writeSparsely) {
377 return self.CreateMatrix2dAttr(
378 UsdPythonToSdfType(defaultVal, SdfValueTypeNames->Matrix2d), writeSparsely);
379 }
380
381 static UsdAttribute
_CreateMatrix3dAttr(UsdContrivedBase & self,object defaultVal,bool writeSparsely)382 _CreateMatrix3dAttr(UsdContrivedBase &self,
383 object defaultVal, bool writeSparsely) {
384 return self.CreateMatrix3dAttr(
385 UsdPythonToSdfType(defaultVal, SdfValueTypeNames->Matrix3d), writeSparsely);
386 }
387
388 static UsdAttribute
_CreateMatrix4dAttr(UsdContrivedBase & self,object defaultVal,bool writeSparsely)389 _CreateMatrix4dAttr(UsdContrivedBase &self,
390 object defaultVal, bool writeSparsely) {
391 return self.CreateMatrix4dAttr(
392 UsdPythonToSdfType(defaultVal, SdfValueTypeNames->Matrix4d), writeSparsely);
393 }
394
395 static UsdAttribute
_CreateFrame4dAttr(UsdContrivedBase & self,object defaultVal,bool writeSparsely)396 _CreateFrame4dAttr(UsdContrivedBase &self,
397 object defaultVal, bool writeSparsely) {
398 return self.CreateFrame4dAttr(
399 UsdPythonToSdfType(defaultVal, SdfValueTypeNames->Frame4d), writeSparsely);
400 }
401
402 static UsdAttribute
_CreateBoolArrayAttr(UsdContrivedBase & self,object defaultVal,bool writeSparsely)403 _CreateBoolArrayAttr(UsdContrivedBase &self,
404 object defaultVal, bool writeSparsely) {
405 return self.CreateBoolArrayAttr(
406 UsdPythonToSdfType(defaultVal, SdfValueTypeNames->BoolArray), writeSparsely);
407 }
408
409 static UsdAttribute
_CreateUcharArrayAttr(UsdContrivedBase & self,object defaultVal,bool writeSparsely)410 _CreateUcharArrayAttr(UsdContrivedBase &self,
411 object defaultVal, bool writeSparsely) {
412 return self.CreateUcharArrayAttr(
413 UsdPythonToSdfType(defaultVal, SdfValueTypeNames->UCharArray), writeSparsely);
414 }
415
416 static UsdAttribute
_CreateIntArrayAttr(UsdContrivedBase & self,object defaultVal,bool writeSparsely)417 _CreateIntArrayAttr(UsdContrivedBase &self,
418 object defaultVal, bool writeSparsely) {
419 return self.CreateIntArrayAttr(
420 UsdPythonToSdfType(defaultVal, SdfValueTypeNames->IntArray), writeSparsely);
421 }
422
423 static UsdAttribute
_CreateUintArrayAttr(UsdContrivedBase & self,object defaultVal,bool writeSparsely)424 _CreateUintArrayAttr(UsdContrivedBase &self,
425 object defaultVal, bool writeSparsely) {
426 return self.CreateUintArrayAttr(
427 UsdPythonToSdfType(defaultVal, SdfValueTypeNames->UIntArray), writeSparsely);
428 }
429
430 static UsdAttribute
_CreateInt64ArrayAttr(UsdContrivedBase & self,object defaultVal,bool writeSparsely)431 _CreateInt64ArrayAttr(UsdContrivedBase &self,
432 object defaultVal, bool writeSparsely) {
433 return self.CreateInt64ArrayAttr(
434 UsdPythonToSdfType(defaultVal, SdfValueTypeNames->Int64Array), writeSparsely);
435 }
436
437 static UsdAttribute
_CreateUint64ArrayAttr(UsdContrivedBase & self,object defaultVal,bool writeSparsely)438 _CreateUint64ArrayAttr(UsdContrivedBase &self,
439 object defaultVal, bool writeSparsely) {
440 return self.CreateUint64ArrayAttr(
441 UsdPythonToSdfType(defaultVal, SdfValueTypeNames->UInt64Array), writeSparsely);
442 }
443
444 static UsdAttribute
_CreateHalfArrayAttr(UsdContrivedBase & self,object defaultVal,bool writeSparsely)445 _CreateHalfArrayAttr(UsdContrivedBase &self,
446 object defaultVal, bool writeSparsely) {
447 return self.CreateHalfArrayAttr(
448 UsdPythonToSdfType(defaultVal, SdfValueTypeNames->HalfArray), writeSparsely);
449 }
450
451 static UsdAttribute
_CreateFloatArrayAttr(UsdContrivedBase & self,object defaultVal,bool writeSparsely)452 _CreateFloatArrayAttr(UsdContrivedBase &self,
453 object defaultVal, bool writeSparsely) {
454 return self.CreateFloatArrayAttr(
455 UsdPythonToSdfType(defaultVal, SdfValueTypeNames->FloatArray), writeSparsely);
456 }
457
458 static UsdAttribute
_CreateDoubleArrayAttr(UsdContrivedBase & self,object defaultVal,bool writeSparsely)459 _CreateDoubleArrayAttr(UsdContrivedBase &self,
460 object defaultVal, bool writeSparsely) {
461 return self.CreateDoubleArrayAttr(
462 UsdPythonToSdfType(defaultVal, SdfValueTypeNames->DoubleArray), writeSparsely);
463 }
464
465 static UsdAttribute
_CreateStringArrayAttr(UsdContrivedBase & self,object defaultVal,bool writeSparsely)466 _CreateStringArrayAttr(UsdContrivedBase &self,
467 object defaultVal, bool writeSparsely) {
468 return self.CreateStringArrayAttr(
469 UsdPythonToSdfType(defaultVal, SdfValueTypeNames->StringArray), writeSparsely);
470 }
471
472 static UsdAttribute
_CreateTokenArrayAttr(UsdContrivedBase & self,object defaultVal,bool writeSparsely)473 _CreateTokenArrayAttr(UsdContrivedBase &self,
474 object defaultVal, bool writeSparsely) {
475 return self.CreateTokenArrayAttr(
476 UsdPythonToSdfType(defaultVal, SdfValueTypeNames->TokenArray), writeSparsely);
477 }
478
479 static UsdAttribute
_CreateAssetArrayAttr(UsdContrivedBase & self,object defaultVal,bool writeSparsely)480 _CreateAssetArrayAttr(UsdContrivedBase &self,
481 object defaultVal, bool writeSparsely) {
482 return self.CreateAssetArrayAttr(
483 UsdPythonToSdfType(defaultVal, SdfValueTypeNames->AssetArray), writeSparsely);
484 }
485
486 static UsdAttribute
_CreateInt2ArrayAttr(UsdContrivedBase & self,object defaultVal,bool writeSparsely)487 _CreateInt2ArrayAttr(UsdContrivedBase &self,
488 object defaultVal, bool writeSparsely) {
489 return self.CreateInt2ArrayAttr(
490 UsdPythonToSdfType(defaultVal, SdfValueTypeNames->Int2Array), writeSparsely);
491 }
492
493 static UsdAttribute
_CreateInt3ArrayAttr(UsdContrivedBase & self,object defaultVal,bool writeSparsely)494 _CreateInt3ArrayAttr(UsdContrivedBase &self,
495 object defaultVal, bool writeSparsely) {
496 return self.CreateInt3ArrayAttr(
497 UsdPythonToSdfType(defaultVal, SdfValueTypeNames->Int3Array), writeSparsely);
498 }
499
500 static UsdAttribute
_CreateInt4ArrayAttr(UsdContrivedBase & self,object defaultVal,bool writeSparsely)501 _CreateInt4ArrayAttr(UsdContrivedBase &self,
502 object defaultVal, bool writeSparsely) {
503 return self.CreateInt4ArrayAttr(
504 UsdPythonToSdfType(defaultVal, SdfValueTypeNames->Int4Array), writeSparsely);
505 }
506
507 static UsdAttribute
_CreateHalf2ArrayAttr(UsdContrivedBase & self,object defaultVal,bool writeSparsely)508 _CreateHalf2ArrayAttr(UsdContrivedBase &self,
509 object defaultVal, bool writeSparsely) {
510 return self.CreateHalf2ArrayAttr(
511 UsdPythonToSdfType(defaultVal, SdfValueTypeNames->Half2Array), writeSparsely);
512 }
513
514 static UsdAttribute
_CreateHalf3ArrayAttr(UsdContrivedBase & self,object defaultVal,bool writeSparsely)515 _CreateHalf3ArrayAttr(UsdContrivedBase &self,
516 object defaultVal, bool writeSparsely) {
517 return self.CreateHalf3ArrayAttr(
518 UsdPythonToSdfType(defaultVal, SdfValueTypeNames->Half3Array), writeSparsely);
519 }
520
521 static UsdAttribute
_CreateHalf4ArrayAttr(UsdContrivedBase & self,object defaultVal,bool writeSparsely)522 _CreateHalf4ArrayAttr(UsdContrivedBase &self,
523 object defaultVal, bool writeSparsely) {
524 return self.CreateHalf4ArrayAttr(
525 UsdPythonToSdfType(defaultVal, SdfValueTypeNames->Half4Array), writeSparsely);
526 }
527
528 static UsdAttribute
_CreateFloat2ArrayAttr(UsdContrivedBase & self,object defaultVal,bool writeSparsely)529 _CreateFloat2ArrayAttr(UsdContrivedBase &self,
530 object defaultVal, bool writeSparsely) {
531 return self.CreateFloat2ArrayAttr(
532 UsdPythonToSdfType(defaultVal, SdfValueTypeNames->Float2Array), writeSparsely);
533 }
534
535 static UsdAttribute
_CreateFloat3ArrayAttr(UsdContrivedBase & self,object defaultVal,bool writeSparsely)536 _CreateFloat3ArrayAttr(UsdContrivedBase &self,
537 object defaultVal, bool writeSparsely) {
538 return self.CreateFloat3ArrayAttr(
539 UsdPythonToSdfType(defaultVal, SdfValueTypeNames->Float3Array), writeSparsely);
540 }
541
542 static UsdAttribute
_CreateFloat4ArrayAttr(UsdContrivedBase & self,object defaultVal,bool writeSparsely)543 _CreateFloat4ArrayAttr(UsdContrivedBase &self,
544 object defaultVal, bool writeSparsely) {
545 return self.CreateFloat4ArrayAttr(
546 UsdPythonToSdfType(defaultVal, SdfValueTypeNames->Float4Array), writeSparsely);
547 }
548
549 static UsdAttribute
_CreateDouble2ArrayAttr(UsdContrivedBase & self,object defaultVal,bool writeSparsely)550 _CreateDouble2ArrayAttr(UsdContrivedBase &self,
551 object defaultVal, bool writeSparsely) {
552 return self.CreateDouble2ArrayAttr(
553 UsdPythonToSdfType(defaultVal, SdfValueTypeNames->Double2Array), writeSparsely);
554 }
555
556 static UsdAttribute
_CreateDouble3ArrayAttr(UsdContrivedBase & self,object defaultVal,bool writeSparsely)557 _CreateDouble3ArrayAttr(UsdContrivedBase &self,
558 object defaultVal, bool writeSparsely) {
559 return self.CreateDouble3ArrayAttr(
560 UsdPythonToSdfType(defaultVal, SdfValueTypeNames->Double3Array), writeSparsely);
561 }
562
563 static UsdAttribute
_CreateDouble4ArrayAttr(UsdContrivedBase & self,object defaultVal,bool writeSparsely)564 _CreateDouble4ArrayAttr(UsdContrivedBase &self,
565 object defaultVal, bool writeSparsely) {
566 return self.CreateDouble4ArrayAttr(
567 UsdPythonToSdfType(defaultVal, SdfValueTypeNames->Double4Array), writeSparsely);
568 }
569
570 static UsdAttribute
_CreatePoint3hArrayAttr(UsdContrivedBase & self,object defaultVal,bool writeSparsely)571 _CreatePoint3hArrayAttr(UsdContrivedBase &self,
572 object defaultVal, bool writeSparsely) {
573 return self.CreatePoint3hArrayAttr(
574 UsdPythonToSdfType(defaultVal, SdfValueTypeNames->Point3hArray), writeSparsely);
575 }
576
577 static UsdAttribute
_CreatePoint3fArrayAttr(UsdContrivedBase & self,object defaultVal,bool writeSparsely)578 _CreatePoint3fArrayAttr(UsdContrivedBase &self,
579 object defaultVal, bool writeSparsely) {
580 return self.CreatePoint3fArrayAttr(
581 UsdPythonToSdfType(defaultVal, SdfValueTypeNames->Point3fArray), writeSparsely);
582 }
583
584 static UsdAttribute
_CreatePoint3dArrayAttr(UsdContrivedBase & self,object defaultVal,bool writeSparsely)585 _CreatePoint3dArrayAttr(UsdContrivedBase &self,
586 object defaultVal, bool writeSparsely) {
587 return self.CreatePoint3dArrayAttr(
588 UsdPythonToSdfType(defaultVal, SdfValueTypeNames->Point3dArray), writeSparsely);
589 }
590
591 static UsdAttribute
_CreateVector3hArrayAttr(UsdContrivedBase & self,object defaultVal,bool writeSparsely)592 _CreateVector3hArrayAttr(UsdContrivedBase &self,
593 object defaultVal, bool writeSparsely) {
594 return self.CreateVector3hArrayAttr(
595 UsdPythonToSdfType(defaultVal, SdfValueTypeNames->Vector3hArray), writeSparsely);
596 }
597
598 static UsdAttribute
_CreateVector3fArrayAttr(UsdContrivedBase & self,object defaultVal,bool writeSparsely)599 _CreateVector3fArrayAttr(UsdContrivedBase &self,
600 object defaultVal, bool writeSparsely) {
601 return self.CreateVector3fArrayAttr(
602 UsdPythonToSdfType(defaultVal, SdfValueTypeNames->Vector3fArray), writeSparsely);
603 }
604
605 static UsdAttribute
_CreateVector3dArrayAttr(UsdContrivedBase & self,object defaultVal,bool writeSparsely)606 _CreateVector3dArrayAttr(UsdContrivedBase &self,
607 object defaultVal, bool writeSparsely) {
608 return self.CreateVector3dArrayAttr(
609 UsdPythonToSdfType(defaultVal, SdfValueTypeNames->Vector3dArray), writeSparsely);
610 }
611
612 static UsdAttribute
_CreateNormal3hArrayAttr(UsdContrivedBase & self,object defaultVal,bool writeSparsely)613 _CreateNormal3hArrayAttr(UsdContrivedBase &self,
614 object defaultVal, bool writeSparsely) {
615 return self.CreateNormal3hArrayAttr(
616 UsdPythonToSdfType(defaultVal, SdfValueTypeNames->Normal3hArray), writeSparsely);
617 }
618
619 static UsdAttribute
_CreateNormal3fArrayAttr(UsdContrivedBase & self,object defaultVal,bool writeSparsely)620 _CreateNormal3fArrayAttr(UsdContrivedBase &self,
621 object defaultVal, bool writeSparsely) {
622 return self.CreateNormal3fArrayAttr(
623 UsdPythonToSdfType(defaultVal, SdfValueTypeNames->Normal3fArray), writeSparsely);
624 }
625
626 static UsdAttribute
_CreateNormal3dArrayAttr(UsdContrivedBase & self,object defaultVal,bool writeSparsely)627 _CreateNormal3dArrayAttr(UsdContrivedBase &self,
628 object defaultVal, bool writeSparsely) {
629 return self.CreateNormal3dArrayAttr(
630 UsdPythonToSdfType(defaultVal, SdfValueTypeNames->Normal3dArray), writeSparsely);
631 }
632
633 static UsdAttribute
_CreateColor3hArrayAttr(UsdContrivedBase & self,object defaultVal,bool writeSparsely)634 _CreateColor3hArrayAttr(UsdContrivedBase &self,
635 object defaultVal, bool writeSparsely) {
636 return self.CreateColor3hArrayAttr(
637 UsdPythonToSdfType(defaultVal, SdfValueTypeNames->Color3hArray), writeSparsely);
638 }
639
640 static UsdAttribute
_CreateColor3fArrayAttr(UsdContrivedBase & self,object defaultVal,bool writeSparsely)641 _CreateColor3fArrayAttr(UsdContrivedBase &self,
642 object defaultVal, bool writeSparsely) {
643 return self.CreateColor3fArrayAttr(
644 UsdPythonToSdfType(defaultVal, SdfValueTypeNames->Color3fArray), writeSparsely);
645 }
646
647 static UsdAttribute
_CreateColor3dArrayAttr(UsdContrivedBase & self,object defaultVal,bool writeSparsely)648 _CreateColor3dArrayAttr(UsdContrivedBase &self,
649 object defaultVal, bool writeSparsely) {
650 return self.CreateColor3dArrayAttr(
651 UsdPythonToSdfType(defaultVal, SdfValueTypeNames->Color3dArray), writeSparsely);
652 }
653
654 static UsdAttribute
_CreateColor4hArrayAttr(UsdContrivedBase & self,object defaultVal,bool writeSparsely)655 _CreateColor4hArrayAttr(UsdContrivedBase &self,
656 object defaultVal, bool writeSparsely) {
657 return self.CreateColor4hArrayAttr(
658 UsdPythonToSdfType(defaultVal, SdfValueTypeNames->Color4hArray), writeSparsely);
659 }
660
661 static UsdAttribute
_CreateColor4fArrayAttr(UsdContrivedBase & self,object defaultVal,bool writeSparsely)662 _CreateColor4fArrayAttr(UsdContrivedBase &self,
663 object defaultVal, bool writeSparsely) {
664 return self.CreateColor4fArrayAttr(
665 UsdPythonToSdfType(defaultVal, SdfValueTypeNames->Color4fArray), writeSparsely);
666 }
667
668 static UsdAttribute
_CreateColor4dArrayAttr(UsdContrivedBase & self,object defaultVal,bool writeSparsely)669 _CreateColor4dArrayAttr(UsdContrivedBase &self,
670 object defaultVal, bool writeSparsely) {
671 return self.CreateColor4dArrayAttr(
672 UsdPythonToSdfType(defaultVal, SdfValueTypeNames->Color4dArray), writeSparsely);
673 }
674
675 static UsdAttribute
_CreateQuathArrayAttr(UsdContrivedBase & self,object defaultVal,bool writeSparsely)676 _CreateQuathArrayAttr(UsdContrivedBase &self,
677 object defaultVal, bool writeSparsely) {
678 return self.CreateQuathArrayAttr(
679 UsdPythonToSdfType(defaultVal, SdfValueTypeNames->QuathArray), writeSparsely);
680 }
681
682 static UsdAttribute
_CreateQuatfArrayAttr(UsdContrivedBase & self,object defaultVal,bool writeSparsely)683 _CreateQuatfArrayAttr(UsdContrivedBase &self,
684 object defaultVal, bool writeSparsely) {
685 return self.CreateQuatfArrayAttr(
686 UsdPythonToSdfType(defaultVal, SdfValueTypeNames->QuatfArray), writeSparsely);
687 }
688
689 static UsdAttribute
_CreateQuatdArrayAttr(UsdContrivedBase & self,object defaultVal,bool writeSparsely)690 _CreateQuatdArrayAttr(UsdContrivedBase &self,
691 object defaultVal, bool writeSparsely) {
692 return self.CreateQuatdArrayAttr(
693 UsdPythonToSdfType(defaultVal, SdfValueTypeNames->QuatdArray), writeSparsely);
694 }
695
696 static UsdAttribute
_CreateMatrix2dArrayAttr(UsdContrivedBase & self,object defaultVal,bool writeSparsely)697 _CreateMatrix2dArrayAttr(UsdContrivedBase &self,
698 object defaultVal, bool writeSparsely) {
699 return self.CreateMatrix2dArrayAttr(
700 UsdPythonToSdfType(defaultVal, SdfValueTypeNames->Matrix2dArray), writeSparsely);
701 }
702
703 static UsdAttribute
_CreateMatrix3dArrayAttr(UsdContrivedBase & self,object defaultVal,bool writeSparsely)704 _CreateMatrix3dArrayAttr(UsdContrivedBase &self,
705 object defaultVal, bool writeSparsely) {
706 return self.CreateMatrix3dArrayAttr(
707 UsdPythonToSdfType(defaultVal, SdfValueTypeNames->Matrix3dArray), writeSparsely);
708 }
709
710 static UsdAttribute
_CreateMatrix4dArrayAttr(UsdContrivedBase & self,object defaultVal,bool writeSparsely)711 _CreateMatrix4dArrayAttr(UsdContrivedBase &self,
712 object defaultVal, bool writeSparsely) {
713 return self.CreateMatrix4dArrayAttr(
714 UsdPythonToSdfType(defaultVal, SdfValueTypeNames->Matrix4dArray), writeSparsely);
715 }
716
717 static UsdAttribute
_CreateFrame4dArrayAttr(UsdContrivedBase & self,object defaultVal,bool writeSparsely)718 _CreateFrame4dArrayAttr(UsdContrivedBase &self,
719 object defaultVal, bool writeSparsely) {
720 return self.CreateFrame4dArrayAttr(
721 UsdPythonToSdfType(defaultVal, SdfValueTypeNames->Frame4dArray), writeSparsely);
722 }
723
724 static std::string
_Repr(const UsdContrivedBase & self)725 _Repr(const UsdContrivedBase &self)
726 {
727 std::string primRepr = TfPyRepr(self.GetPrim());
728 return TfStringPrintf(
729 "UsdContrived.Base(%s)",
730 primRepr.c_str());
731 }
732
733 } // anonymous namespace
734
wrapUsdContrivedBase()735 void wrapUsdContrivedBase()
736 {
737 typedef UsdContrivedBase This;
738
739 class_<This, bases<UsdTyped> >
740 cls("Base");
741
742 cls
743 .def(init<UsdPrim>(arg("prim")))
744 .def(init<UsdSchemaBase const&>(arg("schemaObj")))
745 .def(TfTypePythonClass())
746
747 .def("Get", &This::Get, (arg("stage"), arg("path")))
748 .staticmethod("Get")
749
750 .def("GetSchemaAttributeNames",
751 &This::GetSchemaAttributeNames,
752 arg("includeInherited")=true,
753 return_value_policy<TfPySequenceToList>())
754 .staticmethod("GetSchemaAttributeNames")
755
756 .def("_GetStaticTfType", (TfType const &(*)()) TfType::Find<This>,
757 return_value_policy<return_by_value>())
758 .staticmethod("_GetStaticTfType")
759
760 .def(!self)
761
762
763 .def("GetMyVaryingTokenAttr",
764 &This::GetMyVaryingTokenAttr)
765 .def("CreateMyVaryingTokenAttr",
766 &_CreateMyVaryingTokenAttr,
767 (arg("defaultValue")=object(),
768 arg("writeSparsely")=false))
769
770 .def("GetMyVaryingTokenArrayAttr",
771 &This::GetMyVaryingTokenArrayAttr)
772 .def("CreateMyVaryingTokenArrayAttr",
773 &_CreateMyVaryingTokenArrayAttr,
774 (arg("defaultValue")=object(),
775 arg("writeSparsely")=false))
776
777 .def("GetMyUniformBoolAttr",
778 &This::GetMyUniformBoolAttr)
779 .def("CreateMyUniformBoolAttr",
780 &_CreateMyUniformBoolAttr,
781 (arg("defaultValue")=object(),
782 arg("writeSparsely")=false))
783
784 .def("GetMyDoubleAttr",
785 &This::GetMyDoubleAttr)
786 .def("CreateMyDoubleAttr",
787 &_CreateMyDoubleAttr,
788 (arg("defaultValue")=object(),
789 arg("writeSparsely")=false))
790
791 .def("GetBoolAttr",
792 &This::GetBoolAttr)
793 .def("CreateBoolAttr",
794 &_CreateBoolAttr,
795 (arg("defaultValue")=object(),
796 arg("writeSparsely")=false))
797
798 .def("GetUcharAttr",
799 &This::GetUcharAttr)
800 .def("CreateUcharAttr",
801 &_CreateUcharAttr,
802 (arg("defaultValue")=object(),
803 arg("writeSparsely")=false))
804
805 .def("GetIntAttr",
806 &This::GetIntAttr)
807 .def("CreateIntAttr",
808 &_CreateIntAttr,
809 (arg("defaultValue")=object(),
810 arg("writeSparsely")=false))
811
812 .def("GetUintAttr",
813 &This::GetUintAttr)
814 .def("CreateUintAttr",
815 &_CreateUintAttr,
816 (arg("defaultValue")=object(),
817 arg("writeSparsely")=false))
818
819 .def("GetInt64Attr",
820 &This::GetInt64Attr)
821 .def("CreateInt64Attr",
822 &_CreateInt64Attr,
823 (arg("defaultValue")=object(),
824 arg("writeSparsely")=false))
825
826 .def("GetUint64Attr",
827 &This::GetUint64Attr)
828 .def("CreateUint64Attr",
829 &_CreateUint64Attr,
830 (arg("defaultValue")=object(),
831 arg("writeSparsely")=false))
832
833 .def("GetHalfAttr",
834 &This::GetHalfAttr)
835 .def("CreateHalfAttr",
836 &_CreateHalfAttr,
837 (arg("defaultValue")=object(),
838 arg("writeSparsely")=false))
839
840 .def("GetFloatAttr",
841 &This::GetFloatAttr)
842 .def("CreateFloatAttr",
843 &_CreateFloatAttr,
844 (arg("defaultValue")=object(),
845 arg("writeSparsely")=false))
846
847 .def("GetDoubleAttr",
848 &This::GetDoubleAttr)
849 .def("CreateDoubleAttr",
850 &_CreateDoubleAttr,
851 (arg("defaultValue")=object(),
852 arg("writeSparsely")=false))
853
854 .def("GetStringAttr",
855 &This::GetStringAttr)
856 .def("CreateStringAttr",
857 &_CreateStringAttr,
858 (arg("defaultValue")=object(),
859 arg("writeSparsely")=false))
860
861 .def("GetTokenAttr",
862 &This::GetTokenAttr)
863 .def("CreateTokenAttr",
864 &_CreateTokenAttr,
865 (arg("defaultValue")=object(),
866 arg("writeSparsely")=false))
867
868 .def("GetAssetAttr",
869 &This::GetAssetAttr)
870 .def("CreateAssetAttr",
871 &_CreateAssetAttr,
872 (arg("defaultValue")=object(),
873 arg("writeSparsely")=false))
874
875 .def("GetInt2Attr",
876 &This::GetInt2Attr)
877 .def("CreateInt2Attr",
878 &_CreateInt2Attr,
879 (arg("defaultValue")=object(),
880 arg("writeSparsely")=false))
881
882 .def("GetInt3Attr",
883 &This::GetInt3Attr)
884 .def("CreateInt3Attr",
885 &_CreateInt3Attr,
886 (arg("defaultValue")=object(),
887 arg("writeSparsely")=false))
888
889 .def("GetInt4Attr",
890 &This::GetInt4Attr)
891 .def("CreateInt4Attr",
892 &_CreateInt4Attr,
893 (arg("defaultValue")=object(),
894 arg("writeSparsely")=false))
895
896 .def("GetHalf2Attr",
897 &This::GetHalf2Attr)
898 .def("CreateHalf2Attr",
899 &_CreateHalf2Attr,
900 (arg("defaultValue")=object(),
901 arg("writeSparsely")=false))
902
903 .def("GetHalf3Attr",
904 &This::GetHalf3Attr)
905 .def("CreateHalf3Attr",
906 &_CreateHalf3Attr,
907 (arg("defaultValue")=object(),
908 arg("writeSparsely")=false))
909
910 .def("GetHalf4Attr",
911 &This::GetHalf4Attr)
912 .def("CreateHalf4Attr",
913 &_CreateHalf4Attr,
914 (arg("defaultValue")=object(),
915 arg("writeSparsely")=false))
916
917 .def("GetFloat2Attr",
918 &This::GetFloat2Attr)
919 .def("CreateFloat2Attr",
920 &_CreateFloat2Attr,
921 (arg("defaultValue")=object(),
922 arg("writeSparsely")=false))
923
924 .def("GetFloat3Attr",
925 &This::GetFloat3Attr)
926 .def("CreateFloat3Attr",
927 &_CreateFloat3Attr,
928 (arg("defaultValue")=object(),
929 arg("writeSparsely")=false))
930
931 .def("GetFloat4Attr",
932 &This::GetFloat4Attr)
933 .def("CreateFloat4Attr",
934 &_CreateFloat4Attr,
935 (arg("defaultValue")=object(),
936 arg("writeSparsely")=false))
937
938 .def("GetDouble2Attr",
939 &This::GetDouble2Attr)
940 .def("CreateDouble2Attr",
941 &_CreateDouble2Attr,
942 (arg("defaultValue")=object(),
943 arg("writeSparsely")=false))
944
945 .def("GetDouble3Attr",
946 &This::GetDouble3Attr)
947 .def("CreateDouble3Attr",
948 &_CreateDouble3Attr,
949 (arg("defaultValue")=object(),
950 arg("writeSparsely")=false))
951
952 .def("GetDouble4Attr",
953 &This::GetDouble4Attr)
954 .def("CreateDouble4Attr",
955 &_CreateDouble4Attr,
956 (arg("defaultValue")=object(),
957 arg("writeSparsely")=false))
958
959 .def("GetPoint3hAttr",
960 &This::GetPoint3hAttr)
961 .def("CreatePoint3hAttr",
962 &_CreatePoint3hAttr,
963 (arg("defaultValue")=object(),
964 arg("writeSparsely")=false))
965
966 .def("GetPoint3fAttr",
967 &This::GetPoint3fAttr)
968 .def("CreatePoint3fAttr",
969 &_CreatePoint3fAttr,
970 (arg("defaultValue")=object(),
971 arg("writeSparsely")=false))
972
973 .def("GetPoint3dAttr",
974 &This::GetPoint3dAttr)
975 .def("CreatePoint3dAttr",
976 &_CreatePoint3dAttr,
977 (arg("defaultValue")=object(),
978 arg("writeSparsely")=false))
979
980 .def("GetVector3dAttr",
981 &This::GetVector3dAttr)
982 .def("CreateVector3dAttr",
983 &_CreateVector3dAttr,
984 (arg("defaultValue")=object(),
985 arg("writeSparsely")=false))
986
987 .def("GetVector3fAttr",
988 &This::GetVector3fAttr)
989 .def("CreateVector3fAttr",
990 &_CreateVector3fAttr,
991 (arg("defaultValue")=object(),
992 arg("writeSparsely")=false))
993
994 .def("GetVector3hAttr",
995 &This::GetVector3hAttr)
996 .def("CreateVector3hAttr",
997 &_CreateVector3hAttr,
998 (arg("defaultValue")=object(),
999 arg("writeSparsely")=false))
1000
1001 .def("GetNormal3dAttr",
1002 &This::GetNormal3dAttr)
1003 .def("CreateNormal3dAttr",
1004 &_CreateNormal3dAttr,
1005 (arg("defaultValue")=object(),
1006 arg("writeSparsely")=false))
1007
1008 .def("GetNormal3fAttr",
1009 &This::GetNormal3fAttr)
1010 .def("CreateNormal3fAttr",
1011 &_CreateNormal3fAttr,
1012 (arg("defaultValue")=object(),
1013 arg("writeSparsely")=false))
1014
1015 .def("GetNormal3hAttr",
1016 &This::GetNormal3hAttr)
1017 .def("CreateNormal3hAttr",
1018 &_CreateNormal3hAttr,
1019 (arg("defaultValue")=object(),
1020 arg("writeSparsely")=false))
1021
1022 .def("GetColor3dAttr",
1023 &This::GetColor3dAttr)
1024 .def("CreateColor3dAttr",
1025 &_CreateColor3dAttr,
1026 (arg("defaultValue")=object(),
1027 arg("writeSparsely")=false))
1028
1029 .def("GetColor3fAttr",
1030 &This::GetColor3fAttr)
1031 .def("CreateColor3fAttr",
1032 &_CreateColor3fAttr,
1033 (arg("defaultValue")=object(),
1034 arg("writeSparsely")=false))
1035
1036 .def("GetColor3hAttr",
1037 &This::GetColor3hAttr)
1038 .def("CreateColor3hAttr",
1039 &_CreateColor3hAttr,
1040 (arg("defaultValue")=object(),
1041 arg("writeSparsely")=false))
1042
1043 .def("GetColor4dAttr",
1044 &This::GetColor4dAttr)
1045 .def("CreateColor4dAttr",
1046 &_CreateColor4dAttr,
1047 (arg("defaultValue")=object(),
1048 arg("writeSparsely")=false))
1049
1050 .def("GetColor4fAttr",
1051 &This::GetColor4fAttr)
1052 .def("CreateColor4fAttr",
1053 &_CreateColor4fAttr,
1054 (arg("defaultValue")=object(),
1055 arg("writeSparsely")=false))
1056
1057 .def("GetColor4hAttr",
1058 &This::GetColor4hAttr)
1059 .def("CreateColor4hAttr",
1060 &_CreateColor4hAttr,
1061 (arg("defaultValue")=object(),
1062 arg("writeSparsely")=false))
1063
1064 .def("GetQuatdAttr",
1065 &This::GetQuatdAttr)
1066 .def("CreateQuatdAttr",
1067 &_CreateQuatdAttr,
1068 (arg("defaultValue")=object(),
1069 arg("writeSparsely")=false))
1070
1071 .def("GetQuatfAttr",
1072 &This::GetQuatfAttr)
1073 .def("CreateQuatfAttr",
1074 &_CreateQuatfAttr,
1075 (arg("defaultValue")=object(),
1076 arg("writeSparsely")=false))
1077
1078 .def("GetQuathAttr",
1079 &This::GetQuathAttr)
1080 .def("CreateQuathAttr",
1081 &_CreateQuathAttr,
1082 (arg("defaultValue")=object(),
1083 arg("writeSparsely")=false))
1084
1085 .def("GetMatrix2dAttr",
1086 &This::GetMatrix2dAttr)
1087 .def("CreateMatrix2dAttr",
1088 &_CreateMatrix2dAttr,
1089 (arg("defaultValue")=object(),
1090 arg("writeSparsely")=false))
1091
1092 .def("GetMatrix3dAttr",
1093 &This::GetMatrix3dAttr)
1094 .def("CreateMatrix3dAttr",
1095 &_CreateMatrix3dAttr,
1096 (arg("defaultValue")=object(),
1097 arg("writeSparsely")=false))
1098
1099 .def("GetMatrix4dAttr",
1100 &This::GetMatrix4dAttr)
1101 .def("CreateMatrix4dAttr",
1102 &_CreateMatrix4dAttr,
1103 (arg("defaultValue")=object(),
1104 arg("writeSparsely")=false))
1105
1106 .def("GetFrame4dAttr",
1107 &This::GetFrame4dAttr)
1108 .def("CreateFrame4dAttr",
1109 &_CreateFrame4dAttr,
1110 (arg("defaultValue")=object(),
1111 arg("writeSparsely")=false))
1112
1113 .def("GetBoolArrayAttr",
1114 &This::GetBoolArrayAttr)
1115 .def("CreateBoolArrayAttr",
1116 &_CreateBoolArrayAttr,
1117 (arg("defaultValue")=object(),
1118 arg("writeSparsely")=false))
1119
1120 .def("GetUcharArrayAttr",
1121 &This::GetUcharArrayAttr)
1122 .def("CreateUcharArrayAttr",
1123 &_CreateUcharArrayAttr,
1124 (arg("defaultValue")=object(),
1125 arg("writeSparsely")=false))
1126
1127 .def("GetIntArrayAttr",
1128 &This::GetIntArrayAttr)
1129 .def("CreateIntArrayAttr",
1130 &_CreateIntArrayAttr,
1131 (arg("defaultValue")=object(),
1132 arg("writeSparsely")=false))
1133
1134 .def("GetUintArrayAttr",
1135 &This::GetUintArrayAttr)
1136 .def("CreateUintArrayAttr",
1137 &_CreateUintArrayAttr,
1138 (arg("defaultValue")=object(),
1139 arg("writeSparsely")=false))
1140
1141 .def("GetInt64ArrayAttr",
1142 &This::GetInt64ArrayAttr)
1143 .def("CreateInt64ArrayAttr",
1144 &_CreateInt64ArrayAttr,
1145 (arg("defaultValue")=object(),
1146 arg("writeSparsely")=false))
1147
1148 .def("GetUint64ArrayAttr",
1149 &This::GetUint64ArrayAttr)
1150 .def("CreateUint64ArrayAttr",
1151 &_CreateUint64ArrayAttr,
1152 (arg("defaultValue")=object(),
1153 arg("writeSparsely")=false))
1154
1155 .def("GetHalfArrayAttr",
1156 &This::GetHalfArrayAttr)
1157 .def("CreateHalfArrayAttr",
1158 &_CreateHalfArrayAttr,
1159 (arg("defaultValue")=object(),
1160 arg("writeSparsely")=false))
1161
1162 .def("GetFloatArrayAttr",
1163 &This::GetFloatArrayAttr)
1164 .def("CreateFloatArrayAttr",
1165 &_CreateFloatArrayAttr,
1166 (arg("defaultValue")=object(),
1167 arg("writeSparsely")=false))
1168
1169 .def("GetDoubleArrayAttr",
1170 &This::GetDoubleArrayAttr)
1171 .def("CreateDoubleArrayAttr",
1172 &_CreateDoubleArrayAttr,
1173 (arg("defaultValue")=object(),
1174 arg("writeSparsely")=false))
1175
1176 .def("GetStringArrayAttr",
1177 &This::GetStringArrayAttr)
1178 .def("CreateStringArrayAttr",
1179 &_CreateStringArrayAttr,
1180 (arg("defaultValue")=object(),
1181 arg("writeSparsely")=false))
1182
1183 .def("GetTokenArrayAttr",
1184 &This::GetTokenArrayAttr)
1185 .def("CreateTokenArrayAttr",
1186 &_CreateTokenArrayAttr,
1187 (arg("defaultValue")=object(),
1188 arg("writeSparsely")=false))
1189
1190 .def("GetAssetArrayAttr",
1191 &This::GetAssetArrayAttr)
1192 .def("CreateAssetArrayAttr",
1193 &_CreateAssetArrayAttr,
1194 (arg("defaultValue")=object(),
1195 arg("writeSparsely")=false))
1196
1197 .def("GetInt2ArrayAttr",
1198 &This::GetInt2ArrayAttr)
1199 .def("CreateInt2ArrayAttr",
1200 &_CreateInt2ArrayAttr,
1201 (arg("defaultValue")=object(),
1202 arg("writeSparsely")=false))
1203
1204 .def("GetInt3ArrayAttr",
1205 &This::GetInt3ArrayAttr)
1206 .def("CreateInt3ArrayAttr",
1207 &_CreateInt3ArrayAttr,
1208 (arg("defaultValue")=object(),
1209 arg("writeSparsely")=false))
1210
1211 .def("GetInt4ArrayAttr",
1212 &This::GetInt4ArrayAttr)
1213 .def("CreateInt4ArrayAttr",
1214 &_CreateInt4ArrayAttr,
1215 (arg("defaultValue")=object(),
1216 arg("writeSparsely")=false))
1217
1218 .def("GetHalf2ArrayAttr",
1219 &This::GetHalf2ArrayAttr)
1220 .def("CreateHalf2ArrayAttr",
1221 &_CreateHalf2ArrayAttr,
1222 (arg("defaultValue")=object(),
1223 arg("writeSparsely")=false))
1224
1225 .def("GetHalf3ArrayAttr",
1226 &This::GetHalf3ArrayAttr)
1227 .def("CreateHalf3ArrayAttr",
1228 &_CreateHalf3ArrayAttr,
1229 (arg("defaultValue")=object(),
1230 arg("writeSparsely")=false))
1231
1232 .def("GetHalf4ArrayAttr",
1233 &This::GetHalf4ArrayAttr)
1234 .def("CreateHalf4ArrayAttr",
1235 &_CreateHalf4ArrayAttr,
1236 (arg("defaultValue")=object(),
1237 arg("writeSparsely")=false))
1238
1239 .def("GetFloat2ArrayAttr",
1240 &This::GetFloat2ArrayAttr)
1241 .def("CreateFloat2ArrayAttr",
1242 &_CreateFloat2ArrayAttr,
1243 (arg("defaultValue")=object(),
1244 arg("writeSparsely")=false))
1245
1246 .def("GetFloat3ArrayAttr",
1247 &This::GetFloat3ArrayAttr)
1248 .def("CreateFloat3ArrayAttr",
1249 &_CreateFloat3ArrayAttr,
1250 (arg("defaultValue")=object(),
1251 arg("writeSparsely")=false))
1252
1253 .def("GetFloat4ArrayAttr",
1254 &This::GetFloat4ArrayAttr)
1255 .def("CreateFloat4ArrayAttr",
1256 &_CreateFloat4ArrayAttr,
1257 (arg("defaultValue")=object(),
1258 arg("writeSparsely")=false))
1259
1260 .def("GetDouble2ArrayAttr",
1261 &This::GetDouble2ArrayAttr)
1262 .def("CreateDouble2ArrayAttr",
1263 &_CreateDouble2ArrayAttr,
1264 (arg("defaultValue")=object(),
1265 arg("writeSparsely")=false))
1266
1267 .def("GetDouble3ArrayAttr",
1268 &This::GetDouble3ArrayAttr)
1269 .def("CreateDouble3ArrayAttr",
1270 &_CreateDouble3ArrayAttr,
1271 (arg("defaultValue")=object(),
1272 arg("writeSparsely")=false))
1273
1274 .def("GetDouble4ArrayAttr",
1275 &This::GetDouble4ArrayAttr)
1276 .def("CreateDouble4ArrayAttr",
1277 &_CreateDouble4ArrayAttr,
1278 (arg("defaultValue")=object(),
1279 arg("writeSparsely")=false))
1280
1281 .def("GetPoint3hArrayAttr",
1282 &This::GetPoint3hArrayAttr)
1283 .def("CreatePoint3hArrayAttr",
1284 &_CreatePoint3hArrayAttr,
1285 (arg("defaultValue")=object(),
1286 arg("writeSparsely")=false))
1287
1288 .def("GetPoint3fArrayAttr",
1289 &This::GetPoint3fArrayAttr)
1290 .def("CreatePoint3fArrayAttr",
1291 &_CreatePoint3fArrayAttr,
1292 (arg("defaultValue")=object(),
1293 arg("writeSparsely")=false))
1294
1295 .def("GetPoint3dArrayAttr",
1296 &This::GetPoint3dArrayAttr)
1297 .def("CreatePoint3dArrayAttr",
1298 &_CreatePoint3dArrayAttr,
1299 (arg("defaultValue")=object(),
1300 arg("writeSparsely")=false))
1301
1302 .def("GetVector3hArrayAttr",
1303 &This::GetVector3hArrayAttr)
1304 .def("CreateVector3hArrayAttr",
1305 &_CreateVector3hArrayAttr,
1306 (arg("defaultValue")=object(),
1307 arg("writeSparsely")=false))
1308
1309 .def("GetVector3fArrayAttr",
1310 &This::GetVector3fArrayAttr)
1311 .def("CreateVector3fArrayAttr",
1312 &_CreateVector3fArrayAttr,
1313 (arg("defaultValue")=object(),
1314 arg("writeSparsely")=false))
1315
1316 .def("GetVector3dArrayAttr",
1317 &This::GetVector3dArrayAttr)
1318 .def("CreateVector3dArrayAttr",
1319 &_CreateVector3dArrayAttr,
1320 (arg("defaultValue")=object(),
1321 arg("writeSparsely")=false))
1322
1323 .def("GetNormal3hArrayAttr",
1324 &This::GetNormal3hArrayAttr)
1325 .def("CreateNormal3hArrayAttr",
1326 &_CreateNormal3hArrayAttr,
1327 (arg("defaultValue")=object(),
1328 arg("writeSparsely")=false))
1329
1330 .def("GetNormal3fArrayAttr",
1331 &This::GetNormal3fArrayAttr)
1332 .def("CreateNormal3fArrayAttr",
1333 &_CreateNormal3fArrayAttr,
1334 (arg("defaultValue")=object(),
1335 arg("writeSparsely")=false))
1336
1337 .def("GetNormal3dArrayAttr",
1338 &This::GetNormal3dArrayAttr)
1339 .def("CreateNormal3dArrayAttr",
1340 &_CreateNormal3dArrayAttr,
1341 (arg("defaultValue")=object(),
1342 arg("writeSparsely")=false))
1343
1344 .def("GetColor3hArrayAttr",
1345 &This::GetColor3hArrayAttr)
1346 .def("CreateColor3hArrayAttr",
1347 &_CreateColor3hArrayAttr,
1348 (arg("defaultValue")=object(),
1349 arg("writeSparsely")=false))
1350
1351 .def("GetColor3fArrayAttr",
1352 &This::GetColor3fArrayAttr)
1353 .def("CreateColor3fArrayAttr",
1354 &_CreateColor3fArrayAttr,
1355 (arg("defaultValue")=object(),
1356 arg("writeSparsely")=false))
1357
1358 .def("GetColor3dArrayAttr",
1359 &This::GetColor3dArrayAttr)
1360 .def("CreateColor3dArrayAttr",
1361 &_CreateColor3dArrayAttr,
1362 (arg("defaultValue")=object(),
1363 arg("writeSparsely")=false))
1364
1365 .def("GetColor4hArrayAttr",
1366 &This::GetColor4hArrayAttr)
1367 .def("CreateColor4hArrayAttr",
1368 &_CreateColor4hArrayAttr,
1369 (arg("defaultValue")=object(),
1370 arg("writeSparsely")=false))
1371
1372 .def("GetColor4fArrayAttr",
1373 &This::GetColor4fArrayAttr)
1374 .def("CreateColor4fArrayAttr",
1375 &_CreateColor4fArrayAttr,
1376 (arg("defaultValue")=object(),
1377 arg("writeSparsely")=false))
1378
1379 .def("GetColor4dArrayAttr",
1380 &This::GetColor4dArrayAttr)
1381 .def("CreateColor4dArrayAttr",
1382 &_CreateColor4dArrayAttr,
1383 (arg("defaultValue")=object(),
1384 arg("writeSparsely")=false))
1385
1386 .def("GetQuathArrayAttr",
1387 &This::GetQuathArrayAttr)
1388 .def("CreateQuathArrayAttr",
1389 &_CreateQuathArrayAttr,
1390 (arg("defaultValue")=object(),
1391 arg("writeSparsely")=false))
1392
1393 .def("GetQuatfArrayAttr",
1394 &This::GetQuatfArrayAttr)
1395 .def("CreateQuatfArrayAttr",
1396 &_CreateQuatfArrayAttr,
1397 (arg("defaultValue")=object(),
1398 arg("writeSparsely")=false))
1399
1400 .def("GetQuatdArrayAttr",
1401 &This::GetQuatdArrayAttr)
1402 .def("CreateQuatdArrayAttr",
1403 &_CreateQuatdArrayAttr,
1404 (arg("defaultValue")=object(),
1405 arg("writeSparsely")=false))
1406
1407 .def("GetMatrix2dArrayAttr",
1408 &This::GetMatrix2dArrayAttr)
1409 .def("CreateMatrix2dArrayAttr",
1410 &_CreateMatrix2dArrayAttr,
1411 (arg("defaultValue")=object(),
1412 arg("writeSparsely")=false))
1413
1414 .def("GetMatrix3dArrayAttr",
1415 &This::GetMatrix3dArrayAttr)
1416 .def("CreateMatrix3dArrayAttr",
1417 &_CreateMatrix3dArrayAttr,
1418 (arg("defaultValue")=object(),
1419 arg("writeSparsely")=false))
1420
1421 .def("GetMatrix4dArrayAttr",
1422 &This::GetMatrix4dArrayAttr)
1423 .def("CreateMatrix4dArrayAttr",
1424 &_CreateMatrix4dArrayAttr,
1425 (arg("defaultValue")=object(),
1426 arg("writeSparsely")=false))
1427
1428 .def("GetFrame4dArrayAttr",
1429 &This::GetFrame4dArrayAttr)
1430 .def("CreateFrame4dArrayAttr",
1431 &_CreateFrame4dArrayAttr,
1432 (arg("defaultValue")=object(),
1433 arg("writeSparsely")=false))
1434
1435 .def("__repr__", ::_Repr)
1436 ;
1437
1438 _CustomWrapCode(cls);
1439 }
1440
1441 // ===================================================================== //
1442 // Feel free to add custom code below this line, it will be preserved by
1443 // the code generator. The entry point for your custom code should look
1444 // minimally like the following:
1445 //
1446 // WRAP_CUSTOM {
1447 // _class
1448 // .def("MyCustomMethod", ...)
1449 // ;
1450 // }
1451 //
1452 // Of course any other ancillary or support code may be provided.
1453 //
1454 // Just remember to wrap code in the appropriate delimiters:
1455 // 'namespace {', '}'.
1456 //
1457 // ===================================================================== //
1458 // --(BEGIN CUSTOM CODE)--
1459
1460 namespace {
1461
1462 WRAP_CUSTOM {
1463 }
1464
1465 }
1466