HDK
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
primWrapper.h
Go to the documentation of this file.
1 //
2 // Copyright 2017 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 __GUSD_PRIMWRAPPER_H__
25 #define __GUSD_PRIMWRAPPER_H__
26 
27 #include <GT/GT_Primitive.h>
29 
30 #include "gusd/api.h"
31 
32 #include "pxr/pxr.h"
33 #include "pxr/usd/usd/prim.h"
34 #include "pxr/usd/usd/timeCode.h"
36 
37 #include <functional>
38 
39 #include "GT_Utils.h"
40 #include "purpose.h"
41 
42 class GU_DetailHandle;
43 class GU_PackedImpl;
44 
46 
47 class GusdGT_AttrFilter;
48 class UsdGeomXformCache;
49 class GusdContext;
50 
51 /// \class GusdPrimWrapper
52 /// \brief A GT_Primitive that wraps a USD Prim.
53 ///
54 /// A GusdPrimWrapper is responsible for copying attribute data between
55 /// USD and GT.
56 ///
57 /// To write USD geometry, the following steps are taken:
58 ///
59 /// The ROP uses GusdRefiner to refine the cooked geometry to GT primitive types
60 /// that have a matching USD type.
61 ///
62 /// For each GT primitive we create a primWrapper by calling the defineForWrite
63 /// method. This will create a usd prim on the current stage.
64 ///
65 /// On each frame updateFromGTPrim is called to copy attribtutes from the
66 /// GT prim to the USD prim.
67 ///
68 /// We support:
69 /// Writing a sequence of frames from one process.
70 /// Writing each frame of a sequence to a seperate file from a seperate process.
71 /// Writing each frame of a sequence to a seperate file from one process.
72 ///
73 /// When writing all frames to a single file, we try and compress attribtute values.
74 /// The data we need to do this compression is kept in the prim wrapper.
75 ///
76 /// In the rare case where we want to sequentially write a sequence to per frame
77 /// files, we need the primWrapper to persist across the sequence so we can do
78 /// the attribute compression. However, we need to create the USD prim on each
79 /// per frame file. The "redefine" method is used for this.
80 ///
81 /// To read USD geometry we start with a GusdGU_PackedUSD prim. A GusdGT_PrimCollect
82 /// object has been registered to convert these prims to GT_Primitives for drawing
83 /// in the view port. This object will call the "fullGT" method of the GU prim
84 /// which in turn calls the "defineForRead" to create a GusdPrimWrapper. These
85 /// prims can be refined into native GT_Primitives that the viewport can draw.
86 
87 
88 typedef std::map<SdfPath,UT_Matrix4D> GusdSimpleXformCache;
89 
91 {
92 public:
93 
94  typedef std::function<GT_PrimitiveHandle
95  (const GT_PrimitiveHandle&, /* sourcePrim */
96  const UsdStagePtr&,
97  const SdfPath& /* path */,
98  const GusdContext&)>
100 
101  typedef std::function<GT_PrimitiveHandle
102  (const UsdGeomImageable&,
103  UsdTimeCode,
106 
107  typedef std::function<bool
108  (const GT_PrimitiveHandle&,
109  std::string &primName)>
111 
112  typedef std::function<GT_DataArrayHandle
113  ( const GT_DataArrayHandle & )>
115 
116  /// \brief Given a GT_Primitive, create a USD prim of the proper type.
117  ///
118  /// When writing a USD file, we refine the geometry to a set of prims that we
119  /// can deal with then we call this method on each of those prims.
120  static GT_PrimitiveHandle
121  defineForWrite( const GT_PrimitiveHandle& sourcePrim,
122  const UsdStagePtr& stage,
123  const SdfPath& path,
124  const GusdContext& ctxt);
125 
126  /// If prim type can generate a useful name for a prim, sets primName
127  /// and returns true.
128  /// So far only F3D volumes do this. They can derive a name from meta
129  /// data stored in the f3d file.
130  static bool
131  getPrimName( const GT_PrimitiveHandle &sourcePrim,
132  std::string &primName );
133 
134  // When we write USD for the given type, we will use a name like $USDNAME_0.
135  // where USDNAME is the name registered for this type
136  static const char*
137  getUsdName( int gtPrimId );
138 
139  // When we USD for an object that is marked as a group type, we write
140  // the object and then all its children.
141  static bool
142  isGroupType( int gtPrimId );
143 
144  /// \brief Given a USD prim, create a GusdPrimWrapper of the proper type.
145  ///
146  /// When reading a USD file, we call this function to create a Gusd_GTPrimitive
147  /// for each USD prim, we then refine that to something that can be
148  /// used in a detail.
149  static GT_PrimitiveHandle
150  defineForRead( const UsdGeomImageable& sourcePrim,
152  GusdPurposeSet purposes );
153 
154  /// \brief Is this gt prim a point instancer?
155  ///
156  /// This is used to know if we need to write the instance prototypes.
157  static bool
158  isPointInstancerPrim(const GT_PrimitiveHandle& prim,
159  const GusdContext& ctxt);
160 
161  /// Register function for creating new USD prims from GT_Primitives and, optionally,
162  /// a function for giving these prims a name.
163  static bool registerPrimDefinitionFuncForWrite(int gtPrimId,
165  GetPrimNameFunction getNameFunction = NULL,
166  bool isGroupType = false,
167  const char* usdName = NULL );
168 
169  /// Register function for creating new GusdPrimWrappers from USD prim.
170  static bool registerPrimDefinitionFuncForRead(const TfToken& usdTypeName,
171  DefinitionForReadFunction function);
172 
173  /// Return true is the give prim can be supported directly in USD. This
174  /// is used by the refiner to know when to stop refining.
175  static bool isGTPrimSupported(const GT_PrimitiveHandle& prim);
176 
177  GusdPrimWrapper();
178  GusdPrimWrapper( const UsdTimeCode &time, const GusdPurposeSet &purposes );
180  ~GusdPrimWrapper() override;
181 
182  /// Return true if the underlying USD prim is valid
183  virtual bool isValid() const;
184 
185  virtual const UsdGeomImageable getUsdPrim() const = 0;
186 
187  virtual bool unpack(
188  UT_Array<GU_DetailHandle> &details,
189  const UT_StringRef& fileName,
190  const SdfPath& primPath,
191  const UT_Matrix4D& xform,
192  fpreal frame,
193  const char * viewportLod,
194  GusdPurposeSet purposes,
195  const GT_RefineParms &rparms) const;
196 
197  /// \brief Create a new USD prim to match GT primitive.
198  ///
199  /// When writing per frame USD files, we need to recreate the stage
200  /// and all the primitives on it each frame. However, there is some
201  /// data we want to persist across frames. So we keep the GusdPrimWrappers
202  /// and ask them to redefine their USD prims on each frame.
203  virtual bool redefine(
204  const UsdStagePtr& stage,
205  const SdfPath& path,
206  const GusdContext& ctxt,
207  const GT_PrimitiveHandle& sourcePrim );
208 
209  /// Fill a USD prim's attribute samples for a frame from the
210  /// attributes in a GT primitive.
211  ///
212  /// If \p sourcePrim is an instance, \p localXform is the instance transform
213  /// otherwise it is the primitive transform from the prim.
214  virtual bool updateFromGTPrim(
215  const GT_PrimitiveHandle& sourcePrim,
216  const UT_Matrix4D& houXform,
217  const GusdContext& ctxt,
218  GusdSimpleXformCache& xformCache );
219 
220  /// Add a sample just before the current time that invises this prim.
221  /// For points and instances this means writing a empty point attribute.
222  /// Other prims set their visibility flag.
223  /// It might be possible to avoid this if we are on the first frame.
224  virtual void addLeadingBookend( double curFrame, double startFrame );
225 
226  /// Add a sample at the current frame, invising this from.
227  virtual void addTrailingBookend( double curFrame );
228 
229  /// Keep track of the visibility state of the prim for book marks.
230  void markVisible( bool in ) { m_visible = in; }
231  bool isVisible() const { return m_visible; }
232 
233  virtual void setVisibility(const TfToken& visibility, UsdTimeCode time);
234 
235  static GT_DataArrayHandle convertPrimvarData(
236  const UsdGeomPrimvar& primvar,
237  UsdTimeCode time );
238 
239  static GT_DataArrayHandle convertAttributeData(
240  const UsdAttribute& attr,
241  const VtValue& val);
242 
243  /// Import geometry subsets as either partition attributes or primitive
244  /// groups.
245  static void loadSubsets(const UsdGeomImageable &prim,
246  GT_FaceSetMapPtr &facesets,
247  GT_AttributeListHandle &uniform_attribs,
248  const GT_RefineParms *parms,
249  const int numFaces,
250  UsdTimeCode time);
251 
252  /// Load primvars for prim from USD.
253  /// remapIndicies is used to expand curve primvars into point attributes if
254  /// needed.
255  void loadPrimvars(
256  const UsdPrimDefinition& prim_defn,
258  const GT_RefineParms* rparms,
259  int minUniform,
260  int minPoint,
261  int minVertex,
262  const std::string& primPath,
263  GT_AttributeListHandle* vertex,
264  GT_AttributeListHandle* point,
265  GT_AttributeListHandle* primitive,
266  GT_AttributeListHandle* constant,
267  const GT_DataArrayHandle& remapIndicies = GT_DataArrayHandle() ) const;
268 
269  // Map to translate from GT_Owner enums to USD interpolation type tokens
270  static std::map<GT_Owner, TfToken> s_ownerToUsdInterp;
271  static std::map<GT_Owner, TfToken> s_ownerToUsdInterpCurve;
272 
273 protected:
274 
275  /// Look for "visible" attribute on sourcePrim. If it doesn't exist
276  /// set a visibility sample based on isVisible()
277  void updateVisibilityFromGTPrim( const GT_PrimitiveHandle& sourcePrim,
278  UsdTimeCode time,
279  bool forceWrite = true );
280 
281  /// Look for a "usdactive" attribute on sourcePrim. UsdPrim::SetActive
282  /// based on this value. If attribute doesn't exist, do nothing.
283  void updateActiveFromGTPrim( const GT_PrimitiveHandle& sourcePrim,
284  UsdTimeCode time );
285 
286  void updateTransformFromGTPrim( const GfMatrix4d &xform, UsdTimeCode time, bool force );
287 
288  bool updateAttributeFromGTPrim( GT_Owner owner,
289  const std::string& name,
290  const GT_DataArrayHandle& houAttr,
291  UsdAttribute& usdAttr,
292  UsdTimeCode time );
293 
294  bool updatePrimvarFromGTPrim(
295  const TfToken& name,
296  const GT_Owner& owner,
297  const TfToken& interpolation,
298  UsdTimeCode time,
299  const GT_DataArrayHandle& data );
300 
301  /// Write primvar values from a GT attribute list to USD.
302  bool updatePrimvarFromGTPrim( const GT_AttributeListHandle& gtAttrs,
303  const GusdGT_AttrFilter& primvarFilter,
304  const TfToken& interpolation,
305  UsdTimeCode time );
306 
307  void clearCaches();
308 
309  /// Compute a USD transform from a Houdini transform.
310  ///
311  /// \p houXform is the transform from world to the prim's space in Houdini.
312  /// This includes the object node transformation and the transform of any
313  /// containing packed prim.
314  ///
315  /// \p xformCache is a map of the transforms of any groups that have been
316  /// written on the current frame.
317  static GfMatrix4d computeTransform(
318  const UsdPrim& prim,
319  UsdTimeCode time,
320  const UT_Matrix4D& houXform,
321  const GusdSimpleXformCache& xformCache );
322 
323 protected:
324 
327 
328  bool m_visible;
329 
330  //////////////
331  // Support for collapsing transform values across frames
332 
336 
337  //////////////
338  // Support from collapsing attribute values across frames
339 
341 
343  data = data_;
344  lastSet = time;
345  lastCompared = time;
346  }
347 
351  };
352 
353  typedef std::pair<GT_Owner, std::string> AttrLastValueKeyType;
355 
357 
358  //////////////
359 
360 private:
361 
362  struct GTTypeInfo {
363  DefinitionForWriteFunction writeFunc;
364  GetPrimNameFunction primNameFunc;
365  bool isGroupType;
366  const char * templateName;
367 
368  GTTypeInfo() :
369  writeFunc( NULL ),
370  primNameFunc( NULL ),
371  isGroupType( false ),
372  templateName(NULL) {}
373  GTTypeInfo(
374  DefinitionForWriteFunction writeFunc_,
375  GetPrimNameFunction primNameFunc_,
376  bool isGroupType_,
377  const char * templateName_ ) :
378  writeFunc( writeFunc_ ),
379  primNameFunc( primNameFunc_ ),
380  isGroupType( isGroupType_ ),
381  templateName( templateName_ ) {}
382  };
383 
384  struct TfTokenHashCmp {
385  static bool equal(const TfToken& a, const TfToken& b)
386  { return a == b; }
387 
388  static size_t hash(const TfToken& key)
389  { return key.Hash(); }
390  };
391 
392  typedef UT_Map<int64, GTTypeInfo> GTTypeInfoMap;
393  typedef UT_Set<int64> GTTypeSet;
394  typedef UT_ConcurrentHashMap<
395  TfToken, DefinitionForReadFunction, TfTokenHashCmp>
396  USDTypeToDefineFuncMap;
397 
398  static GTTypeInfoMap s_gtTypeInfoMap;
399  static USDTypeToDefineFuncMap s_usdTypeToFuncMap;
400  static GTTypeSet s_supportedNativeGTTypes;
401 };
402 
404 
405 #endif // __GUSD_PRIMWRAPPER_H__
void markVisible(bool in)
Keep track of the visibility state of the prim for book marks.
Definition: primWrapper.h:230
A GT_Primitive that wraps a USD Prim.
Definition: primWrapper.h:90
Definition: UT_Set.h:58
UsdTimeCode m_lastXformSet
Definition: primWrapper.h:334
GLuint const GLchar * name
Definition: glew.h:1814
AttrLastValueDict m_lastAttrValueDict
Definition: primWrapper.h:356
UsdTimeCode m_time
Definition: primWrapper.h:325
GT_API const UT_StringHolder time
GLuint const GLfloat * val
Definition: glew.h:2794
GLboolean GLboolean GLboolean GLboolean a
Definition: glew.h:9477
std::function< GT_PrimitiveHandle(const GT_PrimitiveHandle &, const UsdStagePtr &, const SdfPath &, const GusdContext &)> DefinitionForWriteFunction
Definition: primWrapper.h:99
AttrLastValueEntry(const UsdTimeCode &time, GT_DataArrayHandle data_)
Definition: primWrapper.h:342
std::pair< GT_Owner, std::string > AttrLastValueKeyType
Definition: primWrapper.h:353
static std::map< GT_Owner, TfToken > s_ownerToUsdInterp
Definition: primWrapper.h:270
std::function< bool(const GT_PrimitiveHandle &, std::string &primName)> GetPrimNameFunction
Definition: primWrapper.h:110
GusdPurposeSet m_purposes
Definition: primWrapper.h:326
Definition: token.h:87
GT_DataArrayHandle data
Definition: primWrapper.h:348
GLuint in
Definition: glew.h:11510
UT_IntrusivePtr< GT_DataArray > GT_DataArrayHandle
Definition: GT_DataArray.h:32
GLint GLenum GLsizei GLint GLsizei const void * data
Definition: glew.h:1379
std::function< GT_DataArrayHandle(const GT_DataArrayHandle &)> ResampleArrayFunction
Definition: primWrapper.h:114
Definition: prim.h:132
UsdTimeCode lastSet
Definition: primWrapper.h:349
GfMatrix4d m_xformCache
Definition: primWrapper.h:333
Definition: path.h:288
The base class for all GT primitive types.
Definition: GT_Primitive.h:43
GT_Owner
Definition: GT_Types.h:76
GLsizei const GLchar *const * path
Definition: glew.h:6461
#define UT_ConcurrentHashMap
GLdouble GLdouble GLdouble b
Definition: glew.h:9122
GLsizei const GLchar *const * string
Definition: glew.h:1844
UsdTimeCode m_lastXformCompared
Definition: primWrapper.h:335
PXR_NAMESPACE_CLOSE_SCOPE PXR_NAMESPACE_OPEN_SCOPE
Definition: path.h:1346
fpreal64 fpreal
Definition: SYS_Types.h:277
Definition: primWrapper.h:340
#define PXR_NAMESPACE_CLOSE_SCOPE
Definition: pxr.h:91
UsdTimeCode lastCompared
Definition: primWrapper.h:350
bool equal(T1 a, T2 b, T3 t)
Definition: ImathFun.h:143
#define GUSD_API
Definition: api.h:40
std::function< GT_PrimitiveHandle(const UsdGeomImageable &, UsdTimeCode, GusdPurposeSet)> DefinitionForReadFunction
Definition: primWrapper.h:105
bool isVisible() const
Definition: primWrapper.h:231
UT_IntrusivePtr< GT_Primitive > GT_PrimitiveHandle
Definition: GT_Handles.h:33
static std::map< GT_Owner, TfToken > s_ownerToUsdInterpCurve
Definition: primWrapper.h:271
GusdPurposeSet
Definition: purpose.h:39
size_t Hash() const
Return a size_t hash for this token.
Definition: token.h:417
std::map< SdfPath, UT_Matrix4D > GusdSimpleXformCache
Definition: primWrapper.h:88
Definition: value.h:174
UT_Map< AttrLastValueKeyType, AttrLastValueEntry > AttrLastValueDict
Definition: primWrapper.h:354