GiBaseVectorizerImpl.h

Go to the documentation of this file.

// Copyright (C) 2002-2024, 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-2024 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_GI_BASE_VECTORIZER_IMPL_H_
#define __OD_GI_BASE_VECTORIZER_IMPL_H_
 
#include "TD_PackPush.h"
 
#include "Gs/GsExport.h"
#include "Gi/GiBaseVectorizer.h"
#include "Gi/GiConveyorEmbranchment.h"
#include "Gi/GiLinetypeRedir.h"
#include "Gi/GiPostTransform.h"
#include "Gi/GiLineweightOverride.h"
#include "Gi/GiStack.h"
#include "Gi/GiPalette.h"
#include "Ps/PlotStyles.h"
#include "Gs/GsViewPropsDef.h"
#include "Gs/GsViewImpl.h"
//FELIX_CHANGE_BEGIN
#include "RxObjectImpl.h"
#include "RxDictionary.h"
#include "RxVariantValue.h"
//FELIX_CHANGE_END

class GS_TOOLKIT_EXPORT OdGiBaseVectorizerImpl: public OdGiViewport, public OdGiBaseVectorizer
{
protected:
  ODRX_USING_HEAP_OPERATORS(OdGiBaseVectorizer);
 
public:
  OdGiBaseVectorizerImpl();

      virtual void setUp(OdGsViewImpl& view);

  OdGsViewImpl& view() const { ODA_ASSERT(m_view); return *m_view; }
  OdUInt32 awareFlags() const { return m_awareFlags.m_nAwareFlags; }
  
  OdUInt32 &awareFlags() { return m_awareFlags.m_nAwareFlags; }

  void resetAwareFlags()
  {
    //NS: traits processing was optimized, but it is not correct
    //Aware flags can be changed when calulating for effective traits in affectTraits(),
    //but on the other hand the flags are reset independently.
    //As a result it is possible that aware flags have no kVpFrozenLayers flag set, but
    //the traits are based on the layer (effective traits are used, unchanged from 
    //the previously processed entity.
#ifdef ENABLE_GITRAITSOPTIMIZATION
    if (m_awareFlags.getFlag(kVpFrozenLayers))
      setEntityTraitsDataChanged(); //force resetting traits
#endif
    m_awareFlags.reset();
  }

  const OdPsPlotStyleData& effectivePlotStyle() const;

  OdGsView::RenderMode getRenderMode() const;

  void clearLinetypeCache();

  void setLinetypesEnabled(bool bEnable);
  
  bool isLinetypesEnabled() const;

  void setSkipViewSectioning(bool bEnable);
  
  bool isViewSectioningSkipped() const;

  void setModelSection(OdGiDrawable* pSection, bool bUseSectionGeometryMap);
  
  const OdGiDrawable* liveSection() const { return m_liveSection; }

  OdGeMatrix3d modelToWorldTransform() const;
  
  OdGeMatrix3d worldToModelTransform() const;

  virtual OdGeMatrix3d objectToDeviceMatrix() const;

  int lineweightToPixels(OdDb::LineWeight lineweight) const;
  
  double lineweightToPixels(double lineweight) const;

  bool hasLineweightOverride() const;
  
  bool hasLinestyleOverride() const;
  
  bool isMultiplyLineStyleScale() const;
  
  const OdGiLineweightOverride *currentLineweightOverride() const;

  ODCOLORREF paletteColor(OdUInt16 colorIndex) const;
  
  ODCOLORREF paletteColor(OdInt16 colorIndex) const { return paletteColor(OdUInt16(colorIndex)); }
  
  const ODCOLORREF *getPalette(int *pNumColors = NULL) const;
  
  bool hasPaletteOverride() const { return !m_paletteOverrideStack.empty(); }

  
  virtual OdGeMatrix3d getModelToEyeTransform() const;
  
  virtual OdGeMatrix3d getEyeToModelTransform() const;
  
  virtual OdGeMatrix3d getWorldToEyeTransform() const;
  
  virtual OdGeMatrix3d getEyeToWorldTransform() const;

  virtual OdGeMatrix3d getWorldToModelTransform() const;
  
  virtual OdGeMatrix3d getModelToWorldTransform() const;

  virtual bool isPerspective() const;
  
  virtual bool doPerspective(OdGePoint3d& point) const;
  
  virtual bool doInversePerspective(OdGePoint3d& point) const;
  
  virtual void getNumPixelsInUnitSquare(
    const OdGePoint3d& point, 
    OdGePoint2d& pixelDensity,
    bool includePerspective = true) const;
 
  
  virtual OdGePoint3d getCameraLocation() const;
  
  virtual OdGePoint3d getCameraTarget() const;
  
  virtual OdGeVector3d getCameraUpVector() const;
  
  
  virtual OdGeVector3d viewDir() const;
  
  virtual OdUInt32 viewportId() const;
  
  virtual OdInt16 acadWindowId() const;
  
  virtual void getViewportDcCorners(
    OdGePoint2d& lowerLeft, 
    OdGePoint2d& upperRight) const;
  
  virtual bool getFrontAndBackClipValues(
    bool& clipFront, 
    bool& clipBack, 
    double& front, 
    double& back) const;
  
  virtual double linetypeScaleMultiplier() const;
  
  virtual double linetypeGenerationCriteria() const;
  
  virtual bool layerVisible(
    OdDbStub* layerId) const;  

  const OdGiContextualColors *contextualColors() const;

  virtual OdDbStub* annotationScaleId() const;


  virtual void pushModelTransform(const OdGeVector3d& normal);
  
  virtual void pushModelTransform(const OdGeMatrix3d & xfm);
  
  virtual void popModelTransform();
  
  virtual void xline(const OdGePoint3d& firstPoint, const OdGePoint3d& secondPoint);
  
  virtual void ray(const OdGePoint3d& basePoint, const OdGePoint3d& throughPoint);
  
  virtual void shell(OdInt32 numVertices, const OdGePoint3d* vertexList, OdInt32 faceListSize, const OdInt32* faceList,
                     const OdGiEdgeData* pEdgeData = 0, const OdGiFaceData* pFaceData = 0, const OdGiVertexData* pVertexData = 0);
  
  virtual void mesh(OdInt32 numRows, OdInt32 numColumns, const OdGePoint3d* vertexList,
                    const OdGiEdgeData* pEdgeData = 0, const OdGiFaceData* pFaceData = 0, const OdGiVertexData* pVertexData = 0);


  virtual void setExtents(const OdGePoint3d *newExtents);


  virtual double deviation(const OdGiDeviationType deviationType,
      const OdGePoint3d& pointOnCurve) const;
  
  virtual OdGiRegenType regenType() const;
  

  virtual OdUInt32 sequenceNumber() const;
  
  virtual bool isValidId(const OdUInt32 viewportId) const;
  
  virtual OdDbStub* viewportObjectId() const;
  
  virtual OdGiViewport& viewport() const;


  virtual void setFillPlane(const OdGeVector3d* pNormal = 0);
  
  virtual void setFillType(OdGiFillType fillType);
  
  virtual OdDbStub* visualStyle() const;
  
  virtual OdUInt32 setupForEntity() const;
  
  virtual bool pushLineweightOverride(const OdGiLineweightOverride *pOverride);
  
  virtual void popLineweightOverride();
  
  virtual bool pushPaletteOverride(const OdGiPalette* pOverride);
  
  virtual void popPaletteOverride();
  
  virtual bool hasPaletteOverrides() const;


  virtual const OdGiViewport* giViewport() const;
  
  virtual const OdGsView* gsView() const;
  
  virtual double annotationScale() const;


  virtual void beginViewVectorization();
  
  virtual void endViewVectorization();
  
  virtual void onTraitsModified();

  virtual const OdGiSubEntityTraitsData& effectiveTraits() const;

  enum VectorizingFlags
  {
    kNotVectorizing = 0,   // Intemediate process (not vectorizing)
    kVectorizing = 1 << 0, // Vectorizing
    kDisplaying  = 1 << 1, // Displaying
    kSelecting   = 1 << 2, // Selection
    kExtentsComp = 1 << 3  // Extents computation
  };

  int vectorizingFlags() const { return m_vectorizingFlags; }
  
  void setVectorizingFlags(int flags) { m_vectorizingFlags = flags; }
protected:
  bool useFillPlane() const;

  virtual const OdGeMatrix3d &metafileTransform() const { return OdGeMatrix3d::kIdentity; }

  inline bool isOutputSuppressed() const;

  bool isEffectiveLinetypeContinuous() const;

  bool isSupportPlotStyles() const;


  virtual void affectTraits(const OdGiSubEntityTraitsData* pSource, OdGiSubEntityTraitsData& destination) const;

  double lineweightToPixelsOverride(OdDb::LineWeight lineweight, bool bAbsolute = false) const;
  int lineweightToPixelsOverrideInt(OdDb::LineWeight lineweight) const;
  double lineweightToPixelsOverride(double lineweight, bool bAbsolute = false) const;

  virtual void updateLineweightOverride(const OdGiLineweightOverride &lwdOverride);
  virtual void updatePaletteOverride(const OdGiPalette *pPalette);
private:
  const OdPsPlotStyleData& plotStyle() const;

  void affect2dTraits(const OdGiSubEntityTraitsData* pFrom, OdGiSubEntityTraitsData& to) const;

  void updateXlineNRayClipper();
  void onModelToEyeChanged();
protected:
  mutable struct AwareFlagsHandler
  {
    OdUInt32 m_nAwareFlags; // Active Aware-flags accumulation register.
    OdUInt32 m_nAffectAwareFlags; // Aware-flags state, accumulated during last affectTraits() call (ref. #CORE-16731).
    AwareFlagsHandler() : m_nAwareFlags(0), m_nAffectAwareFlags(0) { }
    bool getFlag(OdUInt32 nFlag) const { return GETBIT(m_nAwareFlags, nFlag); }
    void setFlag(OdUInt32 nFlag) { SETBIT_1(m_nAwareFlags, nFlag); }
    void setFlag(OdUInt32 nFlag, bool bSet) { SETBIT(m_nAwareFlags, nFlag, bSet); }
    void swapAndSet(OdUInt32 nFlag) { swapFlags(); setFlag(nFlag); }
    void swapFlags() { std::swap(m_nAwareFlags, m_nAffectAwareFlags); }
    void swapAndReset() { swapFlags(); reset(); }
    void mergeFlags() { m_nAwareFlags |= m_nAffectAwareFlags; }
    void swapAndMerge() { swapFlags(); mergeFlags(); }
    void reset() { m_nAwareFlags = 0; }
  } m_awareFlags;
  OdUInt32                    m_implFlags;
  OdGeVector3d                m_fillPlane;
  OdGiContext::PStyleType     m_pstype;
  mutable OdPsPlotStyleData   m_plotStyle;
  OdUInt32                    m_setAttributesHints;
  int                         m_vectorizingFlags;
  OdGiOrthoClipperPtr         m_pXlineNRayClipper;
  OdGiConveyorEntryPoint      m_xlineNRayEntryPoint;
  OdGiLinetypeRedirPtr        m_pLinetyper;
  OdGiPostTransformPtr        m_pPostTransform;
  OdGiConveyorEmbranchmentPtr m_pOutputBranch;
  OdRxObjectPtr               m_pGsReserved; // Reserved pointer for internal use (binary incompatible changes), do not delete.
  OdGiDrawablePtr             m_liveSection;
  OdRxObjectPtr               m_sectionGeometryMap;
  OdCmTransparency            m_sectForegroundFace;
  OdCmTransparency            m_sectForegroundEdge;
 
  OdGiXformPtr                m_pXToLtp;
 
private:
  OdGsViewImpl*               m_view;
  OdGiConveyorConnector       m_ltpEntryPoint;
 
  mutable int                 m_nPenIndex;
  mutable OdDbStub*           m_psnId;
  mutable OdPsPlotStyleData   m_effectivePlotStyle;
 
  OdArray<OdGiLineweightOverride, OdMemoryAllocator<OdGiLineweightOverride> > m_lwdOverrideStack; // Lineweight overrides stack
  OdGiStack<OdGiPalettePtr>   m_paletteOverrideStack; // Palette overrides stack
protected:
  mutable OdGeMatrix3d        m_objectToDeviceMatrix;
protected:
  //DOM-IGNORE-BEGIN
  enum Flags
  {
    kFillPlaneSet               = OdGiBaseVectorizer::kLastFlag <<  1,
    kLinetypeContinuous         = OdGiBaseVectorizer::kLastFlag <<  2,
    kModelCache                 = OdGiBaseVectorizer::kLastFlag <<  3,
    kHighlighted                = OdGiBaseVectorizer::kLastFlag <<  4,
    kDontAbortRegen             = OdGiBaseVectorizer::kLastFlag <<  5,
    kCheckLinePattern           = OdGiBaseVectorizer::kLastFlag <<  6,
    kBreakSelection             = OdGiBaseVectorizer::kLastFlag <<  7,
    kSelectionGeometry          = OdGiBaseVectorizer::kLastFlag <<  8, // Processing geometry which is intended only for selection
    kSelectionDisabled          = OdGiBaseVectorizer::kLastFlag <<  9, // Processing geometry which shouldn't be used for selection
    kObjectToDeviceValid        = OdGiBaseVectorizer::kLastFlag <<  10,
    kDisableInfiniteGeomExtents = OdGiBaseVectorizer::kLastFlag <<  11,
    kSectionableGeomExtentsOnly = OdGiBaseVectorizer::kLastFlag <<  12,
    kDisableSection             = OdGiBaseVectorizer::kLastFlag <<  13,
    kSectionForegroundGeometry  = OdGiBaseVectorizer::kLastFlag <<  14,
    kInitGsState                = OdGiBaseVectorizer::kLastFlag <<  15,
    kSetVpLtypeScaleMult        = OdGiBaseVectorizer::kLastFlag <<  16,
    kSetVpFilterFunction        = OdGiBaseVectorizer::kLastFlag <<  17,
    kLineweightOverride         = OdGiBaseVectorizer::kLastFlag <<  18,
    kLinestyleOverride          = OdGiBaseVectorizer::kLastFlag <<  19,
    kLastOptionFlag             = kLinestyleOverride
    // Note: m_flags and Flags enum bits is nearly complete utilization. Please don't add new flags here.
    //       use m_implFlags and ImplFlags enum instead.
  };
  enum ImplFlags
  {
    kFirstImplFlag              = 1,
    kSectionableGeomEnabled     = kFirstImplFlag << 0,
    kMultiplyLinestyleScale     = kFirstImplFlag << 1,
    kSkipViewSectioning         = kFirstImplFlag << 2,
    kHiddenImplFlag             = kFirstImplFlag << 3,
    kLastImplFlag               = kHiddenImplFlag
  };
};
 
//FELIX_CHANGE_BEGIN
template<typename T, typename>
struct identity { typedef T type; };
 
template < class _DataTy, class _TraitsTy >
class CFxPropertyIntegralTraits
    : public _TraitsTy
{
public:
    static _DataTy getNull()
    {
        return _DataTy( 0 );
    }
};
 
template < class _DataTy, class _TraitsTy >
class CFxDeviceProperty
{
public:
    typedef _TraitsTy Traits;
    static void removeFromDevice( OdGsDevice *device )
    {
        if ( !device )
            return;
        OdRxDictionaryPtr dict = device->properties();
        if ( dict.isNull() )
            return;
        dict->remove( Traits::key() );
    }
    static _DataTy fromDevice( OdGsDevice *device, bool *isValid = 0 )
    {
        if ( !device )
        {
            if (isValid)
                *isValid = false;
            return _DataTy();
        }
        OdRxDictionaryPtr dict = device->properties();
        if ( dict.isNull() )
        {
            if (isValid)
                *isValid = false;
            return _DataTy();
        }
        OdRxVariantValue val(( dict->getAt( Traits::key() ) )) ;
        bool isNull = val.isNull();
        if (isValid)
            *isValid = !isNull;
        return isNull ? ( _DataTy )Traits::getNull() : val.identity< OdRxVariantValue, _DataTy >::type::operator _DataTy();
    }
    static void toDevice( OdGsDevice *device, const _DataTy &val )
    {
        if ( !device )
            return;
        OdRxDictionaryPtr dict = device->properties();
        if ( dict.isNull() )
            return;
        dict->putAt( Traits::key(), OdRxVariantValue( val ) );
    }
};
 
template < class _DataTy, class _TraitsTy >
class CFxDevicePropertyIntegral
    : public CFxDeviceProperty< _DataTy, CFxPropertyIntegralTraits< _DataTy, _TraitsTy > >
{
};
 
template < class _DataTy, class _StorageTy, class _TraitsTy >
class CFxDevicePropertyIntegralCompatible
    : public CFxDeviceProperty< _StorageTy, CFxPropertyIntegralTraits< _DataTy, _TraitsTy > >
{
public:
    typedef CFxDeviceProperty< _StorageTy, CFxPropertyIntegralTraits< _DataTy, _TraitsTy > > _BaseTy;
    static _DataTy fromDevice( OdGsDevice *device, bool *isValid = 0 )
    {
        return (_DataTy)_BaseTy::fromDevice( device, isValid );
    }
    static void toDevice( OdGsDevice *device, const _DataTy &val )
    {
        _StorageTy stor(val);
        return _BaseTy::toDevice(device, val);
    }
};
 
template < class _DataTy, class _TraitsTy, class _PtrTy = OdUInt64 >
class CFxDevicePropertyPtr
    : public CFxDeviceProperty< _PtrTy, CFxPropertyIntegralTraits< _DataTy *, _TraitsTy > >
{
public:
    typedef CFxDeviceProperty< _PtrTy, CFxPropertyIntegralTraits< _DataTy *, _TraitsTy > > Base;
    static _DataTy *allocateAt( OdGsDevice *device, const _DataTy &def )
    {
        if ( !device )
            return 0;
        _DataTy *p = ( _DataTy * )Base::fromDevice( device );
        if ( !p )
        {
            p = new _DataTy( def );
            toDevice( device, p );
        }
        return p;
    }
    static _DataTy *allocateAt( OdGsDevice *device )
    {
        if ( !device )
            return 0;
        _DataTy *p = ( _DataTy * )Base::fromDevice( device );
        if ( !p )
        {
            p = new _DataTy();
            toDevice( device, p );
        }
        return p;
    }
    static void deallocateAt( OdGsDevice *device )
    {
        if ( !device )
            return;
        _DataTy *p = ( _DataTy * )Base::fromDevice( device );
        Base::removeFromDevice( device );
        delete p;
    }
    static _DataTy *fromDevice( OdGsDevice *device, bool *isValid = 0 )
    {
        if ( !device )
            return 0;
        return ( _DataTy * )Base::fromDevice( device, isValid );
    }
    static void toDevice( OdGsDevice *device, const _DataTy *val )
    {
        return Base::toDevice( device, ( _PtrTy ) val );
    }
};
class GS_TOOLKIT_EXPORT CFxPlotGenerationDeviceProperty // Just hints, treat as minimum desired quality settings.
{
public:
    static const OdString key() 
    {
        return OdString( OD_T("IsPlotGeneration") );
    }
};
 
class GS_TOOLKIT_EXPORT CFxRenderHints // Just hints, treat as minimum desired quality settings.
{
public:
    static const OdString key() 
    {
        return OdString( OD_T("FxRenderHints") );
    }
    CFxRenderHints() : geomDpi( 0 ), colorImgDpi( 0 ), bwImgDpi( 0 ), deviceToMmRatio( 1., 1. )
    { }
    int geomDpi, colorImgDpi, bwImgDpi;
    OdGeVector2d deviceToMmRatio;
};
 
class GS_TOOLKIT_EXPORT CFxIsPlotGenerationProperty
    : public CFxDevicePropertyIntegral< bool, CFxPlotGenerationDeviceProperty >
{
};
class GS_TOOLKIT_EXPORT CFxRenderHintsProperty
    : public CFxDevicePropertyPtr< CFxRenderHints, CFxRenderHints >
{
};
//FELIX_CHANGE_END
 
inline bool OdGiBaseVectorizerImpl::isOutputSuppressed() const
{
  return GETBIT(m_vectorizingFlags, kExtentsComp | kSelecting);
}
 
inline void OdGiBaseVectorizerImpl::setLinetypesEnabled(bool bEnable)
{
  if (bEnable) m_pLinetyper->enable();
  else         m_pLinetyper->disable();
}
 
inline bool OdGiBaseVectorizerImpl::isLinetypesEnabled() const
{
  return m_pLinetyper->enabled();
}
 
inline void OdGiBaseVectorizerImpl::setSkipViewSectioning(bool bEnable)
{
  SETBIT(m_implFlags, kSkipViewSectioning, bEnable);
}
 
inline bool OdGiBaseVectorizerImpl::isViewSectioningSkipped() const
{
  return GETBIT(m_implFlags, kSkipViewSectioning);
}
 
inline bool OdGiBaseVectorizerImpl::isSupportPlotStyles() const
{
  return (m_pstype != OdGiContext::kPsNone) && GETBIT(m_setAttributesHints, kHint2DAttributes);
}
 
inline int OdGiBaseVectorizerImpl::lineweightToPixels(OdDb::LineWeight lineweight) const
{
  if (!GETBIT(m_flags, OdGiBaseVectorizerImpl::kLineweightOverride))
    return view().lineweightToPixels(lineweight);
  return lineweightToPixelsOverrideInt(lineweight);
}
 
inline double OdGiBaseVectorizerImpl::lineweightToPixels(double lineweight) const
{
  if (!GETBIT(m_flags, OdGiBaseVectorizerImpl::kLineweightOverride))
    return view().lineweightToPixels(lineweight);
  return lineweightToPixelsOverride(lineweight);
}
 
inline double OdGiBaseVectorizerImpl::lineweightToPixelsOverride(OdDb::LineWeight lineweight, bool bAbsolute) const
{
  return lineweightToPixelsOverride(double(lineweight) / 100.0, bAbsolute);
}
 
inline const OdGiLineweightOverride *OdGiBaseVectorizerImpl::currentLineweightOverride() const
{
  if (GETBIT(m_flags, kLineweightOverride | kLinestyleOverride))
    return  &m_lwdOverrideStack.last();
  return NULL;
}
 
inline bool OdGiBaseVectorizerImpl::hasLineweightOverride() const
{
  return GETBIT(m_flags, OdGiBaseVectorizerImpl::kLineweightOverride);
}
 
inline bool OdGiBaseVectorizerImpl::hasLinestyleOverride() const
{
  return GETBIT(m_flags, OdGiBaseVectorizerImpl::kLinestyleOverride);
}
 
inline bool OdGiBaseVectorizerImpl::isMultiplyLineStyleScale() const
{
  return GETBIT(m_implFlags, OdGiBaseVectorizerImpl::kMultiplyLinestyleScale);
}
 
#include "TD_PackPop.h"
 
#endif // __OD_GI_BASE_VECTORIZER_IMPL_H_