///////////////////////////////////////////////////////////////////////////////
|
// Copyright (C) 2002-2016, 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 Teigha(R) software pursuant to a license
|
// agreement with Open Design Alliance.
|
// Teigha(R) Copyright (C) 2002-2016 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"
|
|
class OdGsBaseModel;
|
class OdGsLayerNode;
|
class OdGsUpdateContext;
|
class OdGiSelectProc;
|
class OdGsEntityNode;
|
class OdGsBlockReferenceNode;
|
class OdGsBlockReferenceNodeImpl;
|
struct OdGsGeomPortion;
|
class OdGsMaterialNode;
|
class OdGsBaseVectorizer;
|
|
class OdGsMtContext;
|
class OdGsUpdateState;
|
class OdGiSharedRefDesc;
|
class OdGiHistory;
|
class OdGiSectionGeometry;
|
|
/** \details
|
|
Library: TD_Gs
|
|
<group OdGs_Classes>
|
*/
|
class GS_TOOLKIT_EXPORT OdGsWriter
|
{
|
public:
|
OdGsWriter();
|
|
/** \details
|
Returns the accumulated extents when writing to the object.
|
*/
|
OdGsExtAccum& extentsAccum()
|
{
|
return *m_pExtAccum.get();
|
}
|
OdGsBaseModel* gsModel() const { return m_pGsModel; }
|
|
bool isRecordingMetafile() { return m_pGeomPortion != 0; }
|
void beginMetafileRecording(OdGsGeomPortion* pGeomPortion) { m_pGeomPortion = pGeomPortion; }
|
void endMetafileRecording();
|
void onNestedDrawable(OdDbStub* layerId);
|
|
bool isLayerFrozen(OdGsLayerNode *pLayerNode) const;
|
private:
|
friend class OdGsBaseVectorizer;
|
void set(OdGsBaseVectorizer* v) { m_vectorizer = v; }
|
void onLayerModified(OdDbStub* layerId);
|
void onLayerModified(OdDbStub* layerId, bool bFrozen);
|
void onFrozenLayerModified(OdDbStub* layerId) const;
|
|
public:
|
OdGsBaseModel* m_pGsModel;
|
|
protected:
|
OdGsExtAccumPtr m_pExtAccum;
|
OdGsGeomPortion* m_pGeomPortion;
|
OdGsBaseVectorizer* m_vectorizer;
|
};
|
|
class OdGiPointLightTraitsData;
|
class OdGiSpotLightTraitsData;
|
class OdGiDistantLightTraitsData;
|
class OdGiWebLightTraitsData;
|
|
/** \details
|
|
Library: TD_Gs
|
|
<group OdGs_Classes>
|
*/
|
class GS_TOOLKIT_EXPORT OdGsBaseVectorizer: public OdGiBaseVectorizerImpl
|
{
|
public:
|
OdGsBaseVectorizer();
|
|
protected:
|
ODRX_USING_HEAP_OPERATORS(OdGiBaseVectorizer);
|
|
public:
|
#ifdef SWIG
|
virtual void draw(const OdGiDrawable* pDrawable) {draw(pDrawable);};
|
#endif
|
/** OdGsBaseVectorizer methods *
|
*/
|
OdGsWriter& gsWriter() { return m_gsWriter; }
|
const OdGsWriter& gsWriter() const { return m_gsWriter; }
|
OdGsExtAccum& gsExtentsAccum() { return gsWriter().extentsAccum(); }
|
|
/** \details
|
Creates a new GsMetafile (cache) object.
|
\remarks
|
Returns a SmartPointer to the newly created object.
|
|
GsMetafiles are used to record vectorizations, and rapidly 'redraw' them to a display device.
|
|
\sa
|
* beginMetafile
|
* endMetafile
|
* playMetafile
|
*/
|
virtual OdRxObjectPtr newGsMetafile();
|
/** \details
|
Begins vectorization to the specified GsMetafile (cache) object.
|
\param pMetafile [in] Pointer to the GsMetafile.
|
\remarks
|
GsMetafiles are used to record vectorizations, and rapidly 'redraw' them to a display device.
|
|
\sa
|
* endMetafile
|
* newGsMetafile
|
* playMetafile
|
*/
|
virtual void beginMetafile(OdRxObject* pMetafile);
|
/** \details
|
Ends vectorization to the specified GsMetafile (cache) object.
|
\param pMetafile [in] Pointer to the GsMetafile.
|
\remarks
|
GsMetafiles are used to record vectorizations, and rapidly 'redraw' them to a display device.
|
|
\sa
|
* beginMetafile
|
* newGsMetafile
|
* playMetafile
|
*/
|
virtual void endMetafile(OdRxObject* pMetafile);
|
|
/** \details
|
Plays (redraws) the specified Metafile (cache) object.
|
\param pMetafile [in] Pointer to the GsMetafile.
|
\remarks
|
GsMetafiles are used to record vectorizations, and rapidly 'redraw' them to a display device.
|
\sa
|
* beginMetafile
|
* endMetafile
|
* newGsMetafile
|
*/
|
virtual void playMetafile(const OdRxObject* pMetafile);
|
|
/** \details
|
Stores the specified Metafile (cache) into OdGsFiler object.
|
\param pMetafile [in] Pointer to the GsMetafile.
|
\param pFiler [in] Pointer to the OdGsFiler object.
|
*/
|
virtual bool saveMetafile(const OdRxObject* pMetafile, OdGsFiler *pFiler);
|
/** \details
|
Loads the Metafile (cache) from OdGsFiler object.
|
\param pFiler [in] Pointer to the OdGsFiler object.
|
*/
|
virtual OdRxObjectPtr loadMetafile(OdGsFiler *pFiler);
|
|
/** \details
|
This method can be called right after endMetafile() to check whether
|
last recorded metafile was empty and optimize stored data.
|
*/
|
bool isMetafileEmpty() const { return m_bMetafileIsEmpty; }
|
|
/** \details
|
Sets viewport's common data before display() call.
|
*/
|
virtual void loadViewport();
|
|
virtual bool forceMetafilesDependence() const;
|
|
virtual bool isViewRegenerated() const;
|
|
/** \details
|
Draws the frame for the viewport.
|
*/
|
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();
|
|
/** OdGiGeometry Overrides *
|
*/
|
void pushModelTransform(const OdGeMatrix3d& xfm);
|
void pushModelTransform(const OdGeVector3d& normal);
|
void popModelTransform();
|
|
void pushClipBoundary(OdGiClipBoundary* pBoundary);
|
void pushClipBoundary(OdGiClipBoundary* pBoundary, OdGiAbstractClipBoundary* pClipInfo);
|
void popClipBoundary();
|
|
/** OdGiBaseVectorizer Overrides *
|
*/
|
virtual void setEntityTraitsDataChanged();
|
virtual void setEntityTraitsDataChanged(int bit, bool value = true);
|
|
/** OdGsBaseVectorizer methods *
|
*/
|
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); }
|
|
/** \details
|
This method sets internal state flag indicating playing mode and calls
|
playMetafile(). The flag can be accessed via isPlayingMfAsGeometry(),
|
see below.
|
*/
|
void playMetafileMode(const OdRxObject* pMetafile, EMetafilePlayMode eMode);
|
/** \details
|
This method returns internal state indicating metafile playing mode.
|
*/
|
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 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);
|
|
/** \details
|
This method returns internal state indicating color fading mode.
|
*/
|
inline bool isFaded() const;
|
inline OdUInt32 fadingIntensity() const;
|
|
inline bool isHighlighted() const;
|
|
inline bool isSelecting() const;
|
|
bool isDragging() const;
|
|
virtual OdGiConveyorOutput& gsExtentsOutput() { return secondaryOutput(); }
|
|
/** \details
|
Controls analytic linetype support for circles and circular arcs in this VectorizeView object.
|
|
\param analytic [in] Analytic linetype support.
|
|
\sa
|
Analytic Linetyping
|
*/
|
virtual void setAnalyticLinetypingCircles(bool analytic);
|
|
/** \details
|
Returns true if and only if analytic linetype support for circles and circular arcs is
|
enabled in this VectorizeView object.
|
|
\sa
|
Analytic Linetyping
|
*/
|
virtual bool isAnalyticLinetypingCircles() const;
|
|
/** \details
|
Controls analytic linetype support for ellipses, elliptical curves,
|
and NURBS curves in this VectorizeView object.
|
|
\param analytic [in] Analytic linetype support.
|
\sa
|
Analytic Linetyping
|
*/
|
virtual void setAnalyticLinetypingComplexCurves(bool analytic);
|
|
/** \details
|
Returns true if and only if analytic linetype support for ellipses, elliptical curves,
|
and NURBS curves is enabled in this VectorizeView object.
|
|
\sa
|
Analytic Linetyping
|
*/
|
virtual bool isAnalyticLinetypingComplexCurves() const;
|
|
//#ifdef GS_INEXACT_SELECTION
|
void checkSelection();
|
//#endif
|
|
virtual bool displayViewportProperties(OdGsPropertiesDirectRenderOutput *pdro = NULL,
|
OdUInt32 incFlags = OdGsProperties::kAll);
|
|
/** \details
|
Returns the secondary output from this vectorizer object.
|
*/
|
OdGiConveyorOutput& secondaryOutput();
|
|
/** OdGiBaseVectorizerImpl methods *
|
*/
|
virtual void setUp(OdGsViewImpl& view);
|
|
/** OdGiBaseVectorizer methods *
|
*/
|
virtual void beginViewVectorization();
|
virtual void endViewVectorization();
|
virtual void onTraitsModified();
|
virtual bool regenAbort() const;
|
virtual bool doDraw(OdUInt32 drawableFlags, const OdGiDrawable* pDrawable);
|
virtual void setSelectionMarker(OdGsMarker selectionMarker);
|
virtual OdGiConveyorOutput& output();
|
virtual void setVisualStyle(OdDbStub *visualStyleId);
|
virtual void setVisualStyle(const OdGiVisualStyle& visualStyle);
|
|
const OdGsMarkerArray* highlightedSubentities() const
|
{ return m_pCurHltBr.get() && m_pCurHltBr->markers().size() ? &m_pCurHltBr->markers() : NULL; }
|
OdGsHlBranch* findHighlightedSubnodeBranch();
|
OdUInt32 threadIndex() const { return m_threadIndex; }
|
|
void highlight(bool bHighlight);
|
/** \details
|
Returns current highlighting data.
|
*/
|
const OdGsHlBranch* currentHighlightBranch() const { return m_pCurHltBr; }
|
|
OdGsLayerNode *activeLayerNode(bool bSync = false) const
|
{ if (bSync) updateLayerTraits(m_effectiveEntityTraitsData);
|
return m_effectiveLayer; }
|
protected:
|
void doSelect(const OdGePoint2d* aPtDc, int numPoints,
|
OdGsSelectionReactor* pReactor, OdGsView::SelectionMode mode);
|
bool doViewExtents(OdGeBoundBlock3d& extents);
|
/** \details
|
Paints the display with each of the drawable objects associated with this VectorizeView object.
|
|
\param update [in] If and only if true, the cache is updated before displaying the drawable.
|
|
\remarks
|
The display is painted for each drawable from one of the following methods in the following order.
|
|
1. Model cache.
|
2. The metafile for the drawable.
|
3. The drawable itself.
|
*/
|
virtual void display(bool bUpdate);
|
/** \details
|
Recomputes the extents for this VectorizeView object.
|
|
\param buildCache [in] Builds Metafile (cache) objects if and only if true.
|
*/
|
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);
|
|
void displayWithoutNesting(OdGsEntityNode *pNode);
|
|
public:
|
void updateExtentsInThreadInit(OdGsMtContext& mtContext);
|
|
private:
|
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; }
|
const OdGsUpdateState* currentState() const { return m_curState; }
|
void applyState(const OdGsUpdateState& s, const OdGsUpdateState& prev);
|
|
public:
|
OdGsHlBranchPtr m_pCurHltBr;
|
protected:
|
bool m_bMetafileIsEmpty;
|
OdGsWriter m_gsWriter;
|
OdGiSelectProc* m_pSelectProc;
|
OdGiConveyorGeometry* m_pDetachedOutput;
|
OdGiConveyorGeometry* m_pDetachedSecondaryOutput;
|
EMetafilePlayMode m_eMfPlayMode;
|
OdGsUpdateState* m_curState;
|
OdGsModel::RenderType m_curRenderType;
|
OdIntPtr m_drawableFilterFunction;
|
// 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;
|
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;
|
};
|
|
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))
|
nIntensityMix = nIntensityMix * (100 - ((m_fadingFlags & kFvLockedLayerMask) >> kFvLockedLayerOffset)) / 100;
|
if (GETBIT(m_fadingFlags, kFfXref) && GETBIT(m_fadingFlags, kEFfXref))
|
nIntensityMix = nIntensityMix * (100 - ((m_fadingFlags & kFvXrefMask) >> kFvXrefOffset)) / 100;
|
if (GETBIT(m_fadingFlags, kFfRefEdit) && GETBIT(m_fadingFlags, kEFfRefEdit))
|
nIntensityMix = nIntensityMix * (100 - ((m_fadingFlags & kFvRefEditMask) >> kFvRefEditOffset)) / 100;
|
return 100 - nIntensityMix;
|
}
|
|
inline bool OdGsBaseVectorizer::isSelecting() const
|
{
|
return m_pSelectProc != 0;
|
}
|
|
inline bool OdGsBaseVectorizer::isHighlighted() const
|
{
|
return GETBIT(m_flags, kHighlighted);
|
}
|
|
#include "TD_PackPop.h"
|
|
#endif // __OD_GS_BASE_VECTORIZER_H_
|
