HDK
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros 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 namespace GABC_NAMESPACE
38 {
39 class GABC_AlembicCache;
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_StringHolder &filename,
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;
143 
144  /// Unpack without using polygon soups
145  virtual bool unpackUsingPolygons(GU_Detail &destgdp) 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_StringHolder &filename() const { return myFilename; }
168  UT_StringHolder intrinsicFilename(const GU_PrimPacked *prim) const { return myFilename; }
169  const UT_StringHolder &objectPath() const { return myObjectPath; }
170  UT_StringHolder intrinsicObjectPath(const GU_PrimPacked *prim) const { return myObjectPath; }
172  { return object().getSourcePath(); }
174  { return object().getPointCount(myFrame); }
175  fpreal frame() const { return myFrame; }
176  fpreal intrinsicFrame(const GU_PrimPacked *prim) const { return myFrame; }
177  bool useTransform() const { return myUseTransform; }
178  bool intrinsicUseTransform(const GU_PrimPacked *prim) const { return myUseTransform; }
179  bool useVisibility() const { return myUseVisibility; }
180  bool intrinsicUseVisibility(const GU_PrimPacked *prim) const { return myUseVisibility; }
181  GABC_NodeType nodeType() const { return object().nodeType(); }
182  GEO_AnimationType animationType() const;
183  int currentLoadStyle() const { return myCache.loadStyle();}
184  bool isConstant() const
185  {
186  return animationType() == GEO_ANIMATION_CONSTANT;
187  }
188  const char *intrinsicAnimation(const GU_PrimPacked *prim) const
189  { return GEOanimationType(animationType()); }
190  const char *intrinsicNodeType(const GU_PrimPacked *prim) const
191  { return GABCnodeType(nodeType()); }
193  { return computeVisibility(false); }
195  { return computeVisibility(true); }
196 
198  { return getAttributeNames(GT_OWNER_POINT); }
200  { return getAttributeNames(GT_OWNER_VERTEX); }
202  { return getAttributeNames(GT_OWNER_PRIMITIVE); }
204  { return getAttributeNames(GT_OWNER_DETAIL); }
206  { return getFaceSetNames(); }
207 
208  /// Returns a sys_wang64 hash of the sum of 64B values making up the Alembic
209  /// property hash.
210  int64 getPropertiesHash() const;
211 
212  void setObject(const GABC_IObject &v);
213  void setFilename(GU_PrimPacked *prim, const UT_StringHolder &v);
214  void setObjectPath(GU_PrimPacked *prim, const UT_StringHolder &v);
215  void setFrame(GU_PrimPacked *prim, fpreal f);
216  void setUseTransform(GU_PrimPacked *prim, bool v);
217  void setUseVisibility(GU_PrimPacked *prim, bool v);
218 
219  void setViewportCache(GABC_AlembicCache *cache) const;
220 protected:
221 #if 0
222  /// Optional method to compute centroid (default uses bounding box)
223  virtual UT_Vector3 getBaryCenter() const;
224  /// Optional method to calculate volume (default uses bounding box)
225  virtual fpreal computeVolume(const UT_Vector3 &refpt) const;
226  /// Optional method to calculate surface area (default uses bounding box)
227  virtual fpreal computeArea() const;
228  /// Optional method to calculate perimeter (default uses bounding box)
229  virtual fpreal computePerimeter() const;
230 #endif
231 
232  /// Method to load from either UT_Options or UT_JSONValueMap
233  template <typename T>
234  bool loadFrom(GU_PrimPacked *prim, const T &options, const GA_LoadMap &map);
235 
236  class GTCache
237  {
238  public:
240  : myAnimationType(GEO_ANIMATION_INVALID)
241  {
242  clear();
243  }
244  GTCache(const GTCache &)
245  : myAnimationType(GEO_ANIMATION_INVALID)
246  {
247  clear(); // Just clear
248  }
250  {
251  clear();
252  }
254  {
255  clear(); // Don't copy, just clear
256  return *this;
257  }
258 
259  int64 getMemoryUsage(bool inclusive) const;
260 
261  void clear(); // Clear all values
262  void updateFrame(fpreal frame);
263 
264  bool visible(const GABC_PackedImpl *abc,
265  bool *is_animated = NULL);
266  const GT_PrimitiveHandle &full(const GABC_PackedImpl *abc,
267  int load_style);
268  const GT_PrimitiveHandle &points(const GABC_PackedImpl *abc);
269  const GT_PrimitiveHandle &box(const GABC_PackedImpl *abc);
270  const GT_PrimitiveHandle &centroid(const GABC_PackedImpl *abc);
271  GEO_AnimationType animationType(const GABC_PackedImpl *abc);
273  { return myAnimationType; }
274 
275  /// Return the current transform handle
277  {
278  refreshTransform(abc);
279  return myTransform;
280  }
281 
282  int loadStyle() const { return myLoadStyle; }
283 
284  private:
285  void refreshTransform(const GABC_PackedImpl *abc);
286  void updateTransform(const GABC_PackedImpl *abc);
287 
288  GT_PrimitiveHandle myPrim;
289  GT_TransformHandle myTransform;
290  GEO_AnimationType myAnimationType;
291  GEO_ViewportLOD myRep;
292  fpreal myFrame;
293  int myLoadStyle;
294  };
295 
296 private:
297  void markDirty(GU_PrimPacked *prim);
298 
299  GABC_VisibilityType computeVisibility(bool include_parent) const;
300 
301  UT_StringHolder getAttributeNames(GT_Owner owner) const;
302  UT_StringHolder getFaceSetNames() const;
303 
304  void clearGT();
305  bool unpackGeometry(GU_Detail &destgdp, bool allow_psoup) const;
306 
307  mutable UT_Lock myLock;
308  mutable GABC_IObject myObject;
309  mutable GTCache myCache;
310  mutable bool myCachedUniqueID;
311  mutable int64 myUniqueID;
312  UT_StringHolder myFilename;
313  UT_StringHolder myObjectPath;
314  fpreal myFrame;
315  bool myUseTransform;
316  bool myUseVisibility;
317 
318  mutable GABC_VisibilityType myConstVisibility;
319  mutable bool myHasConstBounds;
320  mutable UT_BoundingBox myConstBounds;
321  mutable GABC_AlembicCache *myViewportCache;
322 
323  static GA_PrimitiveTypeId theTypeId;
324 };
325 
326 }
327 
328 #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 hboost::disable_if_c< VecTraits< T >::IsVec, T >::type & min(const T &a, const T &b)
Definition: Composite.h:128
const UT_StringHolder & filename() 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:72
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
const hboost::disable_if_c< VecTraits< T >::IsVec, T >::type & max(const T &a, const T &b)
Definition: Composite.h:132
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:100
int64 intrinsicPointCount(const GU_PrimPacked *prim) const
GLfloat f
Definition: glcorearb.h:1925
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
bool intrinsicUseVisibility(const GU_PrimPacked *prim) const
GT_Owner
Definition: GT_Types.h:72
fpreal intrinsicFrame(const GU_PrimPacked *prim) const
double fpreal
Definition: SYS_Types.h:263
A map of string to various well defined value types.
Definition: UT_Options.h:42
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
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