GsBaseVectorizer.h

Go to the documentation of this file.

 
// Copyright (C) 2002-2022, Open Design Alliance (the "Alliance"). 
// All rights reserved. 
// 
// This software and its documentation and related materials are owned by 
// the Alliance. The software may only be incorporated into application 
// programs owned by members of the Alliance, subject to a signed 
// Membership Agreement and Supplemental Software License Agreement with the
// Alliance. The structure and organization of this software are the valuable  
// trade secrets of the Alliance and its suppliers. The software is also 
// protected by copyright law and international treaty provisions. Application  
// programs incorporating this software must include the following statement 
// with their copyright notices:
//   
//   This application incorporates Open Design Alliance software pursuant to a license 
//   agreement with Open Design Alliance.
//   Open Design Alliance Copyright (C) 2002-2022 by Open Design Alliance. 
//   All rights reserved.
//
// By use of this software, its documentation or related materials, you 
// acknowledge and accept the above terms.
 
#ifndef __OD_GS_BASE_VECTORIZER_H_
#define __OD_GS_BASE_VECTORIZER_H_
 
#include "TD_PackPush.h"
 
#include "Gs/GsExport.h"
#include "Gs/GiBaseVectorizerImpl.h"
#include "Gs/GsExtAccum.h"
#include "Gs/GsModel.h"
#include "GsMarkerArray.h"
#include "Gs/GsHighlightData.h"
 
#define STL_USING_SET
#include <set>
 
class OdGsBaseModel;
class OdGsLayerNode;
class OdGsUpdateContext;
class OdGiSelectProc;
class OdGiCollideProc;
class OdGsEntityNode;
class OdGsBlockReferenceNode;
class OdGsBlockReferenceNodeImpl;
struct OdGsGeomPortion;
class OdGsMaterialNode;
class OdGsBaseVectorizer;
class OdGsBaseContext;
class OdGsDisplayContext;
struct OdSiShape;
 
class OdGsMtContext;
class OdGsUpdateState;
class OdGsNestedMetafile;
class OdGiSharedRefDesc;
class OdGiHistory;
class OdGiSectionGeometry;
class OdGsApplyModelOverrides;
 
class OdPerfTimerBase;
 
 
typedef std::set<OdGsMarker> OdGsMarkerSet;
typedef OdSharedPtr< OdGsApplyModelOverrides > OdGsApplyModelOverridesPtr;
 
class GS_TOOLKIT_EXPORT OdGsWriter
{
public:
  OdGsWriter();
 
  OdGsExtAccum& extentsAccum()
  {
    return *m_pExtAccum.get();
  }
 
  OdGsBaseModel* gsModel() const { return m_pGsModel; }
 
  bool isRecordingMetafile() { return m_pGeomPortion != 0; }
 
  OdGsGeomPortion *currentGeomPortion() const { return m_pGeomPortion; }
 
  OdGsGeomPortion *headGeomPortion() const { return m_pGeomPortionHead; }
 
  void beginMetafileRecording(OdGsGeomPortion* pGeomPortion) { m_pGeomPortionHead = m_pGeomPortion = pGeomPortion; }
 
  void endMetafileRecording();
  void onNestedDrawable(OdDbStub* layerId, const OdGsNestedMetafile *pNestedMf = NULL);
  void separateMetafile();
 
  bool isLayerFrozen(OdGsLayerNode *pLayerNode) const;
 
  bool hasFrozenLayerBefore(OdGsLayerNode *pLayerNode, const OdGsGeomPortion *pTillPortion = NULL) const;
private:
  //DOM-IGNORE-BEGIN
  friend class OdGsBaseVectorizer;
  void set(OdGsBaseVectorizer* v) { m_vectorizer = v; }
  void onLayerModified(OdDbStub* layerId, bool bFrozen, bool bFromSetAttribs);
  void onLayerModified(OdDbStub* layerId) { onLayerModified(layerId, false, false); }
  void onSetAttributesLayer(OdDbStub *layerId) { onLayerModified(layerId, false, true); }
  void onFrozenLayerModified(OdDbStub* layerId) { onLayerModified(layerId, true, false); }
 
public:
  OdGsBaseModel* m_pGsModel;
 
protected:
  bool isCurrentGeomPortionDiscardable();
protected:
  OdGsExtAccumPtr m_pExtAccum;
  OdGsGeomPortion* m_pGeomPortionHead;
  OdGsGeomPortion* m_pGeomPortion;
  OdGsBaseVectorizer* m_vectorizer;
  bool m_bFinalizedMetafile;
  //DOM-IGNORE-END
};
 
class OdGiPointLightTraitsData;
class OdGiSpotLightTraitsData;
class OdGiDistantLightTraitsData;
class OdGiWebLightTraitsData;
 
class GS_TOOLKIT_EXPORT OdGsBaseVectorizer: public OdGiBaseVectorizerImpl
{
public:
  OdGsBaseVectorizer();
 
protected:
  //DOM-IGNORE-BEGIN
  ODRX_USING_HEAP_OPERATORS(OdGiBaseVectorizer);
  //DOM-IGNORE-END
 
public:  
#ifdef SWIG
  virtual void draw(const OdGiDrawable* pDrawable) {draw(pDrawable);};
#endif
  OdGsWriter& gsWriter() { return m_gsWriter; }
 
  const OdGsWriter& gsWriter() const { return m_gsWriter; }
 
  OdGsExtAccum& gsExtentsAccum() { return gsWriter().extentsAccum(); }
 
  virtual OdRxObjectPtr newGsMetafile();
 
  virtual void beginMetafile(OdRxObject* pMetafile);
 
  virtual void endMetafile(OdRxObject* pMetafile);
 
  virtual void playMetafile(const OdRxObject* pMetafile);
 
  virtual bool saveMetafile(const OdRxObject* pMetafile, OdGsFiler *pFiler);
 
  virtual OdRxObjectPtr loadMetafile(OdGsFiler *pFiler);
 
  bool isMetafileEmpty() const { return m_nMetafileSize == 0; }
  
  OdUInt64 lastMetafileSize() const 
  {
    if( m_nMetafileSize != OdUInt64( -1 ) ) return m_nMetafileSize;
    return 0;
  }
 
  virtual void loadViewport();
 
  virtual bool forceMetafilesDependence() const;
 
  virtual bool isViewRegenerated() const;
 
  virtual void drawViewportFrame();
 
  virtual void updateViewport();
 
 
  // Materials support
 
  virtual void processMaterialNode(OdDbStub *materialId, OdGsMaterialNode *pNode);
  
  virtual bool saveMaterialCache(const OdGsMaterialNode *pNode, OdGsFiler *pFiler);
 
  virtual bool loadMaterialCache(OdGsMaterialNode *pNode, OdGsFiler *pFiler);
 
  virtual void addPointLight(const OdGiPointLightTraitsData&) {}
 
  virtual void addSpotLight(const OdGiSpotLightTraitsData&) {}
 
  virtual void addDistantLight(const OdGiDistantLightTraitsData&) {}
 
  virtual void addWebLight(const OdGiWebLightTraitsData&);
  // default implementation call's addPointLight
 
  ~OdGsBaseVectorizer();
 
  void pushModelTransform(const OdGeMatrix3d& xfm);
 
  void pushModelTransform(const OdGeVector3d& normal);
 
  void popModelTransform();
 
  void pushClipBoundary(OdGiClipBoundary* pBoundary);
 
  void pushClipBoundary(OdGiClipBoundary* pBoundary, OdGiAbstractClipBoundary* pClipInfo);
 
  void popClipBoundary();
 
  virtual void setEntityTraitsDataChanged();
 
  virtual void setEntityTraitsDataChanged(int bit, bool value = true);
 
  virtual OdGeMatrix3d objectToDeviceMatrix() const;
 
  virtual bool pushPaletteOverride(const OdGiPalette* pOverride);
 
  virtual void popPaletteOverride();
 
  virtual bool hasPaletteOverrides() const;
 
  bool disableInfiniteGeomExtents() const { return GETBIT(m_flags, kDisableInfiniteGeomExtents); }
  bool sectionableGeomExtentsOnly() const { return GETBIT(m_flags, kSectionableGeomExtentsOnly); }
  void setSectionableGeomExtentsOnly(bool bOn) { SETBIT(m_flags, kSectionableGeomExtentsOnly, bOn); }
 
  void playMetafileMode(const OdRxObject* pMetafile, EMetafilePlayMode eMode, OdGsEntityNode& node, OdGsBaseContext* ctx);
 
  virtual bool playNestedMetafile(const OdGsGeomPortion* pPortion, OdGsBaseContext* pContext, OdGsEntityNode& node);
 
  EMetafilePlayMode metafilePlayMode() const { return m_eMfPlayMode;  }
 
  enum MetafileTransformFlags
  {
    kSharedRefTransform = (1 << 0),
    kSharedRefUpdate    = (1 << 1),
    kSharedRefSelect    = (1 << 2)
  };
 
  virtual void pushMetafileTransform(const OdGeMatrix3d&, OdUInt32 = 0);
 
  virtual void popMetafileTransform(OdUInt32 = 0);
 
  virtual const OdGeMatrix3d &metafileTransform() const;
 
  virtual bool useSharedBlockReferences() const { return true; }
  virtual bool useMetafileAsGeometry() const { return false; }
  virtual OdGiConveyorOutput& outputForMetafileGeometry();
  virtual void setTransformForMetafileGeometry(const OdGeMatrix3d&) {}
  virtual OdGeMatrix3d getTransformForMetafileGeometry() const { return OdGeMatrix3d::kIdentity; }
  virtual void reportUpdateError(OdDbStub* /*entityId*/, const OdError& error)
  {
#ifdef ODA_DIAGNOSTICS
    throw error;
#else
    ODA_ASSERT(error); // prevent arg unused warning
#endif
  }
 
  OdGsLayerNode* gsLayerNode(OdDbStub* layerId, OdGsBaseModel* pModel);
 
  inline bool isFaded() const;
 
  inline OdUInt32 fadingIntensity() const;
 
  inline bool isHighlighted() const;
 
  inline bool isSelecting() const;
 
  inline bool isHidden() const;
 
  inline void setHidden( bool bHidden );
 
  bool isDragging() const;
 
  virtual OdGiConveyorOutput& gsExtentsOutput() { return secondaryOutput(); }
 
  virtual void setAnalyticLinetypingCircles(bool analytic);
 
  virtual bool isAnalyticLinetypingCircles() const;
 
  virtual void setAnalyticLinetypingComplexCurves(bool analytic);
 
  virtual bool isAnalyticLinetypingComplexCurves() const;
 
  void checkSelection();
 
  bool handleSelectionByExtents( const OdGeExtents3d& extWc );
 
  virtual bool displayViewportProperties(OdGsPropertiesDirectRenderOutput *pdro = NULL,
      OdUInt32 incFlags = OdGsProperties::kAll);
 
  OdGiConveyorOutput& secondaryOutput();
 
  // OdGiBaseVectorizerImpl methods
 
  virtual void setUp(OdGsViewImpl& view);
 
  // OdGiBaseVectorizer methods
 
  virtual void beginViewVectorization();
 
  virtual void endViewVectorization();
 
  virtual void onTraitsModified();
 
  virtual double deviation(const OdGiDeviationType deviationType, const OdGePoint3d& pointOnCurve) const;
 
  virtual bool regenAbort() const;
 
  virtual bool doDraw(OdUInt32 drawableFlags, const OdGiDrawable* pDrawable);
 
  virtual void setSelectionMarker(OdGsMarker selectionMarker);
  virtual OdGiConveyorOutput& output();
 
  virtual void setVisualStyle(const OdGiVisualStyle& visualStyle);
 
  const OdGsMarkerSet* highlightedSubentities() const;
 
  OdGsStateBranch* findHighlightedSubnodeBranch();
  OdUInt32 threadIndex() const;
 
  void highlight(bool bHighlight, OdUInt32 nSelStyle = 0);
 
  const OdGsStateBranch* currentHighlightBranch() const;
 
  const OdGsStateBranch* currentVisibilityBranch() const;
 
  OdGsStateBranch* findHiddenSubnodeBranch();
 
  OdGsLayerNode *activeLayerNode(bool bSync = false) const;
 
  OdGsModel::RenderType activeRenderType() const;
 
  OdGsOverlayId activeOverlay() const;
 
  virtual bool isSpatialIndexDisabled() const { return false; }
 
  virtual void beginMetafileRecording(OdGsGeomPortion* pGeomPortion);
 
  virtual void endMetafileRecording();
 
  struct BlockScopesCallback
  {
    virtual void blockBegin(const void *pRefId) = 0;
    virtual void blockEnd(const void *pRefId) = 0;
  };
protected:
  //DOM-IGNORE-BEGIN
  void doSelect(const OdGePoint2d* aPtDc, int numPoints,
      OdGsSelectionReactor* pReactor, OdGsView::SelectionMode mode);
  bool doViewExtents(OdGeBoundBlock3d& extents);
  virtual void display(bool bUpdate);
  virtual void updateExtents(bool bBuildCache);
 
  // OdGiBaseVectorizer methods
  virtual const OdGiLayerTraitsData& effectiveLayerTraits() const;
  virtual OdDbStub* switchLayer(OdDbStub* layerId) const;
 
  void selectionMarkerOnChange(OdGsMarker nSelectionMarker);
 
  void checkRenderType(const OdGsModel *pModel);
  virtual void renderTypeOnChange(OdGsModel::RenderType renderType);
  virtual void switchOverlay(OdGsOverlayId overlayId);
 
  void initDeviationMultiplier();
  double handleDeviationMultiplier(const OdGiDeviationType deviationType, double dDeviationValue) const;
 
  void displayWithoutNesting(OdGsEntityNode *pNode, BlockScopesCallback *pBlockScopesCbk = NULL);
 
  virtual void displayNode(OdGsNode& node, OdGsDisplayContext& ctx);
  virtual void displaySubnode(OdGsEntityNode& node, OdGsDisplayContext& ctx, bool bHighlighted);
 
  void doDrawLight(const OdGiDrawable* pDrawable);
  bool isSharedGraphicsState() const;
  const OdGsUpdateState* currentState() const { return m_curState; }
 
  virtual bool updateExtentsOnly() const ODRX_OVERRIDE;
  //DOM-IGNORE-END
public:
 
  virtual OdUInt32 setAttributes(const OdGiDrawable* pDrawable);
 
  void updateExtentsInThreadInit(OdGsMtContext& mtContext);
 
private:
  //DOM-IGNORE-BEGIN
  void setInitGsState(bool bOn);
  bool isRecordingHistory();
  void deleteHistory();
  void setThreadIndex(OdUInt32 idx) { m_threadIndex = idx; }
  bool drawSectionable(const OdGiDrawable& drawable, bool& bRes);
  bool drawSectionGeometry(OdGiSectionGeometry& geom, bool bVpModelTfAwareBefore);
  void setCurrentState(OdGsUpdateState& newState);
  OdGsUpdateState* currentState() { return m_curState; }
  void applyState(const OdGsUpdateState& s, const OdGsUpdateState& prev);
  //DOM-IGNORE-END
public:
  OdGsStateBranchPtr m_pCurHltBr; // Current highlight branch
  OdGsStateBranchPtr m_pCurVisibilityBr; // Current visibility branch 
protected:
  //DOM-IGNORE-BEGIN
  OdArray<OdGeMatrix3d> m_metafileTransfStack;
  OdUInt64 m_nMetafileSize;
  OdGsWriter m_gsWriter;
  OdGiSelectProc* m_pSelectProc;
  OdGiCollideProc* m_pCollideProc;
  OdGiConveyorGeometry* m_pDetachedOutput;
  OdGiConveyorGeometry* m_pDetachedSecondaryOutput;
  const OdSiShape* m_MfPlayQuery; // Currently playing query
  const OdGsEntityNode* m_MfPlayNode; // Currently playing node
  EMetafilePlayMode m_eMfPlayMode;
  OdGsUpdateState* m_curState;
  OdGsModel::RenderType m_curRenderType;
  OdGsOverlayId m_curOverlay;
  double m_dDeviationMultiplier;
  OdIntPtr m_drawableFilterFunction;
  OdGsMaterialNode *m_pCachedMaterial;
  // Fading support
  enum FadingFlags
  {
    kFfLockedLayer       = (1 << 0),
    kFfXref              = (1 << 1),
    kFfRefEdit           = (1 << 2),
    kFfFlagsMask         = kFfLockedLayer  | kFfXref  | kFfRefEdit,
    kEFfLockedLayer      = (1 << 4),
    kEFfXref             = (1 << 5),
    kEFfRefEdit          = (1 << 6),
    kEFfFlagsMask        = kEFfLockedLayer | kEFfXref | kEFfRefEdit,
    kEFfFlagsOffset      = 4,
    kFvLockedLayerOffset = 8,
    kFvLockedLayerMask   = (0xFF << kFvLockedLayerOffset),
    kFvXrefOffset        = 16,
    kFvXrefMask          = (0xFF << kFvXrefOffset),
    kFvRefEditOffset     = 24,
    kFvRefEditMask       = (0xFF << kFvRefEditOffset)
  };
  OdUInt32 m_fadingFlags;
  template <OdGiContext::FadingType fadingType> friend class OdGsLockFadingFlag;
 
  OdUInt32 m_selectionStyle;
  //DOM-IGNORE-END
public:
 
  OdUInt32 currentSelectionStyle() const { return m_selectionStyle; }
 
  bool hasSelectionStyle() const { return m_selectionStyle != 0; }
 
  int highlightingPass() const;
 
  void setRenderAbort( bool bSet );
 
  virtual bool renderAbort();
protected:
  //DOM-IGNORE-BEGIN
  enum BaseVectorizerFlags
  {
    kRenderAbort            = OdGiBaseVectorizerImpl::kLastImplFlag << 1,
    kViewInteractive        = OdGiBaseVectorizerImpl::kLastImplFlag << 2,
    kHighlightFirstPass     = OdGiBaseVectorizerImpl::kLastImplFlag << 3,
    kHighlightSecondPass    = OdGiBaseVectorizerImpl::kLastImplFlag << 4,
    kAbsoluteDeviation      = OdGiBaseVectorizerImpl::kLastImplFlag << 5,
 
    kLastBaseVectorizerFlag = kAbsoluteDeviation
  };
  double m_dRenderAbortCondition;
  OdPerfTimerBase* m_viewTimingProcessor;
 
  const OdGsExtAccum *secondaryOutputExtents() const { return m_pOutputExtents.get(); }
  OdGsExtAccum *secondaryOutputExtents() { return m_pOutputExtents.get(); }
private:
  mutable const OdGiLayerTraitsData* m_pCachedLayer;
  OdGsLayerNode* m_effectiveLayer;
  OdGsExtAccumPtr m_pOutputExtents;
  OdGiHistory* m_giHistory;
  OdUInt32 m_threadIndex;
  bool m_bTraitsDataChanged;
  bool m_bByBlockTraitsChanged;
  friend class OdGsUpdateContext;
  friend class OdGsDisplayContext;
  friend class OdGsBaseVectorizeView;
  friend class OdGsApplyModelOverrides;
 
protected:
  virtual void doCollide( OdGiPathNode const*const* pInputList, OdUInt32 nInputListSize, OdGsCollisionDetectionReactor* pReactor, OdGiPathNode const*const* pCollisionWithList = NULL, OdUInt32 nCollisionWithListSize = 0, const OdGsCollisionDetectionContext* pCtx = NULL );
  virtual void doCollideAll( OdGsCollisionDetectionReactor* pReactor, const OdGsCollisionDetectionContext* pCtx = NULL );
  void processDrawableForCollide( const OdGiPathNode* pStartNode, const OdGiDrawable* pDrawable, OdGsBaseModel*& pCurModel, OdGsApplyModelOverridesPtr& pCurOverrides );
  void processAllDrawablesForCollide( const OdGeExtents3d* pExtents = NULL, OdGiPathNode const*const* pCollisionWithList = NULL, OdUInt32 nCollisionWithListSize = 0, bool bIgnoreViewExtents = false );
  //DOM-IGNORE-END
};
 
template <typename ClientClass = OdGsBaseVectorizer>
class OdGsHighlightingStateSaver
{
  protected:
    ClientClass& m_vect;
    const bool m_bHighlighted;
    const OdUInt32 m_selStyle;
  public:
    OdGsHighlightingStateSaver(ClientClass &vect)
      : m_vect(vect)
      , m_bHighlighted(vect.isHighlighted())
      , m_selStyle(vect.currentSelectionStyle())
    { }
    ~OdGsHighlightingStateSaver()
    { m_vect.highlight(m_bHighlighted, m_selStyle); }
    bool isHighlighted() const { return m_bHighlighted; }
    OdUInt32 selectionStyle() const { return m_selStyle; }
};
 
template <OdGiContext::FadingType fadingType>
class OdGsLockFadingFlag
{
  protected:
    OdUInt32 &m_lockedFlags;
    bool m_bSavedBit;
  public:
    OdGsLockFadingFlag(OdGsBaseVectorizer &vectorizer)
      : m_lockedFlags(vectorizer.m_fadingFlags)
      , m_bSavedBit(GETBIT(vectorizer.m_fadingFlags, 1 << fadingType))
    {}
    void set(bool bNewVal) { SETBIT(m_lockedFlags, 1 << fadingType, bNewVal); }
    OdGsLockFadingFlag(OdGsBaseVectorizer &vectorizer, bool bNewVal)
      : m_lockedFlags(vectorizer.m_fadingFlags)
      , m_bSavedBit(GETBIT(vectorizer.m_fadingFlags, 1 << fadingType))
    { set(bNewVal); }
    ~OdGsLockFadingFlag() { set(m_bSavedBit); }
};
 
inline bool OdGsBaseVectorizer::isFaded() const
{ // Returns true in case if any type of fading is 'true' and fading value is positive
  return !!((m_fadingFlags & kFfFlagsMask) & ((m_fadingFlags & kEFfFlagsMask) >> kEFfFlagsOffset));
}
 
inline OdUInt32 OdGsBaseVectorizer::fadingIntensity() const
{ // Returns percentage in [0-100] range
  OdUInt32 nIntensityMix = 100;
  if (GETBIT(m_fadingFlags, kFfLockedLayer) && GETBIT(m_fadingFlags, kEFfLockedLayer))
  {
    OdUInt32 mix = 100 - ((m_fadingFlags & kFvLockedLayerMask) >> kFvLockedLayerOffset);
    nIntensityMix = mix;
  }
  if (GETBIT(m_fadingFlags, kFfXref) && GETBIT(m_fadingFlags, kEFfXref))
  {
    OdUInt32 mix = 100 - ((m_fadingFlags & kFvXrefMask) >> kFvXrefOffset);
    nIntensityMix = odmin(nIntensityMix, mix);
  }
  if (GETBIT(m_fadingFlags, kFfRefEdit) && GETBIT(m_fadingFlags, kEFfRefEdit))
  {
    OdUInt32 mix = 100 - ((m_fadingFlags & kFvRefEditMask) >> kFvRefEditOffset);
    nIntensityMix = nIntensityMix * mix / 100;
  }
  nIntensityMix = odmax(10, nIntensityMix);
  return 100 - nIntensityMix;
}
 
inline const OdGsMarkerSet* OdGsBaseVectorizer::highlightedSubentities() const
{
  return m_pCurHltBr.get() && m_pCurHltBr->markersSize() ? &m_pCurHltBr->markers() : NULL;
}
 
inline OdUInt32 OdGsBaseVectorizer::threadIndex() const
{
  return m_threadIndex;
}
 
inline const OdGsStateBranch* OdGsBaseVectorizer::currentHighlightBranch() const
{
  return m_pCurHltBr;
}
 
inline const OdGsStateBranch* OdGsBaseVectorizer::currentVisibilityBranch() const
{
  return m_pCurVisibilityBr;
}
 
inline OdGsLayerNode *OdGsBaseVectorizer::activeLayerNode(bool bSync) const
{
  if (bSync)
    updateLayerTraits(m_effectiveEntityTraitsData);
  return m_effectiveLayer;
}
 
inline OdGsModel::RenderType OdGsBaseVectorizer::activeRenderType() const
{
  return m_curRenderType;
}
 
inline OdGsOverlayId OdGsBaseVectorizer::activeOverlay() const
{
  return m_curOverlay;
}
 
inline bool OdGsBaseVectorizer::isSelecting() const
{
    return m_pSelectProc != 0;
}
 
inline void OdGsBaseVectorizer::highlight(bool bHighlight, OdUInt32 nSelStyle)
{
  SETBIT(m_flags, kHighlighted, bHighlight);
  m_selectionStyle = nSelStyle;
}
 
inline bool OdGsBaseVectorizer::isHighlighted() const
{
  return GETBIT(m_flags, kHighlighted);
}
 
inline int OdGsBaseVectorizer::highlightingPass() const
{
  return GETBIT(m_implFlags, kHighlightFirstPass) ? 1 : (GETBIT(m_implFlags, kHighlightSecondPass) ? 2 : 0);
}
 
inline bool OdGsBaseVectorizer::isHidden() const
{
  return GETBIT(m_implFlags, kHiddenImplFlag);
}
 
inline void OdGsBaseVectorizer::setHidden( bool bHidden )
{
  SETBIT( m_implFlags, kHiddenImplFlag, bHidden );
}
 
inline const OdGeMatrix3d &OdGsBaseVectorizer::metafileTransform() const
{ // Metafile transformation matrix
  return m_metafileTransfStack.isEmpty() ? OdGeMatrix3d::kIdentity : m_metafileTransfStack.last();
}
 
#include "TD_PackPop.h"
 
#endif // __OD_GS_BASE_VECTORIZER_H_