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