HDK
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
GABC_PackedImpl.h
Go to the documentation of this file.
1 /*
2  * Copyright (c) COPYRIGHTYEAR
3  * Side Effects Software Inc. All rights reserved.
4  *
5  * Redistribution and use of Houdini Development Kit samples in source and
6  * binary forms, with or without modification, are permitted provided that the
7  * following conditions are met:
8  * 1. Redistributions of source code must retain the above copyright notice,
9  * this list of conditions and the following disclaimer.
10  * 2. The name of Side Effects Software may not be used to endorse or
11  * promote products derived from this software without specific prior
12  * written permission.
13  *
14  * THIS SOFTWARE IS PROVIDED BY SIDE EFFECTS SOFTWARE `AS IS' AND ANY EXPRESS
15  * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
16  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN
17  * NO EVENT SHALL SIDE EFFECTS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT,
18  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
19  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
20  * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
21  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
22  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
23  * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24  *
25  *----------------------------------------------------------------------------
26  */
27 
28 #ifndef __GABC_PackedImpl__
29 #define __GABC_PackedImpl__
30 
31 #include "GABC_API.h"
32 #include "GABC_Util.h"
33 #include <GU/GU_PackedImpl.h>
34 #include <GT/GT_Primitive.h>
35 #include <UT/UT_Lock.h>
36 
37 
38 namespace GABC_NAMESPACE
39 {
40 
42 {
43 public:
44  static void install(GA_PrimitiveFactory *fact);
45  static bool isInstalled();
47  {
48  return theTypeId;
49  }
50 
53  virtual ~GABC_PackedImpl();
54 
55  /// Note: The caller is responsible for setting the vertex/point for the
56  /// primitive.
57  /// In non-Alembic packed primitive code, you probably just want to call
58  /// GU_PrimPacked::build(gdp, "AlembicRef")
59  /// which handles the point creation automatically (see the packedsphere
60  /// HDK sample code).
61  static GU_PrimPacked *build(GU_Detail &gdp,
62  const UT_StringArray &filenames,
63  const GABC_IObject &obj,
64  fpreal frame,
65  bool useTransform,
66  bool useVisibility);
67 
68 
69  /// Get the factory associated with this procedural
70  virtual GU_PackedFactory *getFactory() const;
71 
72  /// Create a copy of this resolver
73  virtual GU_PackedImpl *copy() const;
74 
75  /// Report memory usage (includes all shared memory)
76  virtual int64 getMemoryUsage(bool inclusive) const;
77 
78  /// Count memory usage using a UT_MemoryCounter in order to count
79  /// shared memory correctly.
80  virtual void countMemory(UT_MemoryCounter &counter, bool inclusive) const;
81 
82  /// Test whether the deferred load primitive data is valid
83  virtual bool isValid() const;
84 
85  /// Method to clear any data associated with the implementation. It's
86  /// possible that the implementation may need to re-construct the data, but
87  /// this should clear what it can.
88  virtual void clearData();
89 
90  /// Give a UT_Options of load data, create resolver data for the primitive
91  virtual bool load(GU_PrimPacked *prim, const UT_Options &options,
92  const GA_LoadMap &map)
93  { return loadFrom(prim, options, map); }
94  virtual bool supportsJSONLoad() const { return true; }
95  virtual bool loadFromJSON(GU_PrimPacked *prim, const UT_JSONValueMap &options,
96  const GA_LoadMap &map)
97  { return loadFrom(prim, options, map); }
98 
99  /// Depending on the update, the procedural should call one of:
100  /// - prim->transformDirty()
101  /// - prim->attributeDirty()
102  /// - prim->topologyDirty()
103  virtual void update(GU_PrimPacked *prim, const UT_Options &options);
104 
105  /// Copy the resolver data into the UT_Options for saving
106  virtual bool save(UT_Options &options,
107  const GA_SaveMap &map) const;
108 
109  /// Handle unknown token/value pairs when loading the primitive. By
110  /// default, this adds a warning and skips the next object. Return false
111  /// if there was a critical error.
112  virtual bool loadUnknownToken(const char *token, UT_JSONParser &p,
113  const GA_LoadMap &map);
114 
115  /// Get the bounding box for the geometry (not including transforms)
116  virtual bool getBounds(UT_BoundingBox &box) const;
117 
118  /// Get the rendering bounding box for the geometry (not including
119  /// transforms). For curve and point geometry, this needs to include any
120  /// "width" attributes.
121  virtual bool getRenderingBounds(UT_BoundingBox &box) const;
122 
123  /// When rendering with velocity blur, the renderer needs to know the
124  /// bounds on velocity to accurately compute the bounding box.
125  virtual void getVelocityRange(UT_Vector3 &min,
126  UT_Vector3 &max) const;
127  virtual void getWidthRange(fpreal &min, fpreal &max) const;
128 
129  /// Return the primitive's "description". This should be a unique
130  /// identifier for the primitive and defaults to:
131  /// <tt>"%s.%d" % (getFactory()->name(), prim->getMapIndex()) </tt>
132  virtual void getPrimitiveName(const GU_PrimPacked *prim, UT_WorkBuffer &wbuf) const;
133 
134  /// Some procedurals have an "intrinsic" transform. These are combined
135  /// with the local transform on the geometry primitive.
136  ///
137  /// The default method returns false and leaves the transform unchanged.
138  virtual bool getLocalTransform(UT_Matrix4D &m) const;
139 
140  /// Unpack the procedural into a GU_Detail. By default, this calls
141  /// getGTFull() and converts the GT geometry to a GU_Detail.
142  virtual bool unpack(GU_Detail &destgdp, const UT_Matrix4D *transform) const;
143 
144  /// Unpack without using polygon soups
145  virtual bool unpackUsingPolygons(GU_Detail &destgdp, const GU_PrimPacked *prim) const;
146 
147  /// @{
148  /// Return GT representations of geometry
149  bool visibleGT(bool *is_animated = NULL) const;
150  GT_PrimitiveHandle fullGT(int load_style=GABC_IObject::GABC_LOAD_FULL) const;
151  GT_PrimitiveHandle pointGT() const;
152  GT_PrimitiveHandle boxGT() const;
153  GT_PrimitiveHandle centroidGT() const;
154  /// @}
155 
156  /// Get the geometry for "instancing". This geometry doesn't have the
157  /// transform to world space, nor does it have the Houdini attributes from
158  /// the primitive.
159  GT_PrimitiveHandle instanceGT(bool ignore_visibility = false) const;
160 
161  /// The xformGT will return the transform for the primitive, regardless of
162  /// whether the load_style for full geometry was set to force untransformed
163  /// geometry.
164  GT_TransformHandle xformGT() const;
165 
166  const GABC_IObject &object() const;
167  const UT_StringArray &filenames() const { return myFilenames; }
168  UT_StringHolder filenamesJSON() const;
170  {
171  if (myFilenames.size())
172  return myFilenames.last();
173  return "";
174  }
175  UT_StringHolder intrinsicFilenamesJSON(const GU_PrimPacked *prim) const;
176  const UT_StringHolder &objectPath() const { return myObjectPath; }
177  UT_StringHolder intrinsicObjectPath(const GU_PrimPacked *prim) const { return myObjectPath; }
179  { return object().getSourcePath(); }
181  { return object().getPointCount(myFrame); }
182  fpreal frame() const { return myFrame; }
183  fpreal intrinsicFrame(const GU_PrimPacked *prim) const { return myFrame; }
184  bool useTransform() const { return myUseTransform; }
185  bool intrinsicUseTransform(const GU_PrimPacked *prim) const { return myUseTransform; }
186  bool useVisibility() const { return myUseVisibility; }
187  bool intrinsicUseVisibility(const GU_PrimPacked *prim) const { return myUseVisibility; }
188  GABC_NodeType nodeType() const { return object().nodeType(); }
189  GEO_AnimationType animationType() const;
190  int currentLoadStyle() const { return myCache.loadStyle();}
191  bool isConstant() const
192  {
193  return animationType() == GEO_ANIMATION_CONSTANT;
194  }
195  const char *intrinsicAnimation(const GU_PrimPacked *prim) const
196  { return GEOanimationType(animationType()); }
197  const char *intrinsicNodeType(const GU_PrimPacked *prim) const
198  { return GABCnodeType(nodeType()); }
200  { return computeVisibility(false); }
202  { return computeVisibility(true); }
203 
205  { return getAttributeNames(GT_OWNER_POINT); }
207  { return getAttributeNames(GT_OWNER_VERTEX); }
209  { return getAttributeNames(GT_OWNER_PRIMITIVE); }
211  { return getAttributeNames(GT_OWNER_DETAIL); }
213  { return getFaceSetNames(); }
214 
215  /// Returns a sys_wang64 hash of the sum of 64B values making up the Alembic
216  /// property hash.
217  int64 getPropertiesHash() const;
218 
219  void setObject(const GABC_IObject &v);
220  void setFilename(GU_PrimPacked *prim, const UT_StringHolder &v);
221  void setFilenames(GU_PrimPacked *prim, const UT_StringArray &v);
222  void setFilenamesJSON(GU_PrimPacked *prim, const UT_StringHolder &v);
223  void setObjectPath(GU_PrimPacked *prim, const UT_StringHolder &v);
224  void setFrame(GU_PrimPacked *prim, fpreal f);
225  void setUseTransform(GU_PrimPacked *prim, bool v);
226  void setUseVisibility(GU_PrimPacked *prim, bool v);
227 
228 protected:
229 #if 0
230  /// Optional method to compute centroid (default uses bounding box)
231  virtual UT_Vector3 getBaryCenter() const;
232  /// Optional method to calculate volume (default uses bounding box)
233  virtual fpreal computeVolume(const UT_Vector3 &refpt) const;
234  /// Optional method to calculate surface area (default uses bounding box)
235  virtual fpreal computeArea() const;
236  /// Optional method to calculate perimeter (default uses bounding box)
237  virtual fpreal computePerimeter() const;
238 #endif
239 
240  /// Method to load from either UT_Options or UT_JSONValueMap
241  template <typename T>
242  bool loadFrom(GU_PrimPacked *prim, const T &options, const GA_LoadMap &map);
243 
244  class GTCache
245  {
246  public:
248  : myAnimationType(GEO_ANIMATION_INVALID)
249  {
250  clear();
251  }
252  GTCache(const GTCache &)
253  : myAnimationType(GEO_ANIMATION_INVALID)
254  {
255  clear(); // Just clear
256  }
258  {
259  clear();
260  }
262  {
263  clear(); // Don't copy, just clear
264  return *this;
265  }
266 
267  int64 getMemoryUsage(bool inclusive) const;
268 
269  void clear(); // Clear all values
270  void updateFrame(fpreal frame);
271 
272  bool visible(const GABC_PackedImpl *abc,
273  bool *is_animated = NULL);
274  const GT_PrimitiveHandle &full(const GABC_PackedImpl *abc,
275  int load_style);
276  const GT_PrimitiveHandle &points(const GABC_PackedImpl *abc);
277  const GT_PrimitiveHandle &box(const GABC_PackedImpl *abc);
278  const GT_PrimitiveHandle &centroid(const GABC_PackedImpl *abc);
279  GEO_AnimationType animationType(const GABC_PackedImpl *abc);
281  { return myAnimationType; }
282 
283  /// Return the current transform handle
285  {
286  refreshTransform(abc);
287  return myTransform;
288  }
289 
290  int loadStyle() const { return myLoadStyle; }
291 
292  private:
293  void refreshTransform(const GABC_PackedImpl *abc);
294  void updateTransform(const GABC_PackedImpl *abc);
295 
296  GT_PrimitiveHandle myPrim;
297  GT_TransformHandle myTransform;
298  GEO_AnimationType myAnimationType;
299  GEO_ViewportLOD myRep;
300  fpreal myFrame;
301  int myLoadStyle;
302  };
303 
304 private:
305  void markDirty(GU_PrimPacked *prim);
306 
307  GABC_VisibilityType computeVisibility(bool include_parent) const;
308 
309  UT_StringHolder getAttributeNames(GT_Owner owner) const;
310  UT_StringHolder getFaceSetNames() const;
311 
312  void clearGT();
313  bool unpackGeometry(GU_Detail &destgdp, const UT_Matrix4D *transform, bool allow_psoup) const;
314 
315  mutable UT_Lock myLock;
316  mutable GABC_IObject myObject;
317  mutable GTCache myCache;
318  mutable bool myCachedUniqueID;
319  mutable int64 myUniqueID;
320  UT_StringArray myFilenames;
321  UT_StringHolder myObjectPath;
322  fpreal myFrame;
323  bool myUseTransform;
324  bool myUseVisibility;
325 
326  mutable GABC_VisibilityType myConstVisibility;
327  mutable bool myHasConstBounds;
328  mutable UT_BoundingBox myConstBounds;
329 
330  static GA_PrimitiveTypeId theTypeId;
331 };
332 
333 }
334 
335 #endif
UT_StringHolder intrinsicDetail(const GU_PrimPacked *prim) const
GABC_API const char * GABCnodeType(GABC_NodeType type)
UT_JSONValueMap stores a map/dictionary of UT_JSONValue objects.
Used to pass options and map offset values during saving.
Definition: GA_SaveMap.h:48
UT_StringHolder intrinsicPoint(const GU_PrimPacked *prim) const
const GLdouble * v
Definition: glcorearb.h:836
GTCache & operator=(const GTCache &src)
JSON reader class which handles parsing of JSON or bJSON files.
Definition: UT_JSONParser.h:75
GEO_API const char * GEOanimationType(GEO_AnimationType type)
UT_StringHolder intrinsicFaceSet(const GU_PrimPacked *prim) const
GEO_AnimationType animationType() const
#define GABC_NAMESPACE
Definition: GABC_API.h:42
bool intrinsicUseTransform(const GU_PrimPacked *prim) const
virtual bool loadFromJSON(GU_PrimPacked *prim, const UT_JSONValueMap &options, const GA_LoadMap &map)
long long int64
Definition: SYS_Types.h:107
int64 intrinsicPointCount(const GU_PrimPacked *prim) const
GLfloat f
Definition: glcorearb.h:1925
const std::enable_if<!VecTraits< T >::IsVec, T >::type & max(const T &a, const T &b)
Definition: Composite.h:133
GEO_AnimationType
UT_StringHolder intrinsicFilename(const GU_PrimPacked *prim) const
const char * intrinsicAnimation(const GU_PrimPacked *prim) const
Options during loading.
Definition: GA_LoadMap.h:42
GABC_NodeType nodeType() const
virtual bool load(GU_PrimPacked *prim, const UT_Options &options, const GA_LoadMap &map)
Give a UT_Options of load data, create resolver data for the primitive.
int64 intrinsicFullVisibility(const GU_PrimPacked *prim) const
GA_API const UT_StringHolder transform
bool intrinsicUseVisibility(const GU_PrimPacked *prim) const
GT_Owner
Definition: GT_Types.h:75
fpreal intrinsicFrame(const GU_PrimPacked *prim) const
double fpreal
Definition: SYS_Types.h:270
A map of string to various well defined value types.
Definition: UT_Options.h:42
const UT_StringArray & filenames() const
virtual bool supportsJSONLoad() const
GEO_ViewportLOD
UT_StringHolder intrinsicSourcePath(const GU_PrimPacked *prim) const
#define GABC_API
Definition: GABC_API.h:37
int64 intrinsicVisibility(const GU_PrimPacked *prim) const
static GA_PrimitiveTypeId typeId()
const char * intrinsicNodeType(const GU_PrimPacked *prim) const
UT_StringHolder intrinsicPrimitive(const GU_PrimPacked *prim) const
UT_StringHolder intrinsicObjectPath(const GU_PrimPacked *prim) const
const std::enable_if<!VecTraits< T >::IsVec, T >::type & min(const T &a, const T &b)
Definition: Composite.h:129
UT_StringHolder intrinsicVertex(const GU_PrimPacked *prim) const
const UT_StringHolder & objectPath() const
const GT_TransformHandle & xform(const GABC_PackedImpl *abc)
Return the current transform handle.
GLenum src
Definition: glcorearb.h:1792