GsViewImpl.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 ODGSVIEWIMPL_INC
#define ODGSVIEWIMPL_INC
 
#include "TD_PackPush.h"
#include "Gs/Gs.h"
#include "Gs/GsBaseModule.h"
#include "Gs/GsDCRectArray.h"
#include "DbStubPtrArray.h"
#include "Ge/GePoint3d.h"
#include "Ge/GeVector3d.h"
#include "Ge/GeMatrix3d.h"
#include "UInt8Array.h"
#include "SharedPtr.h"
#include "Gs/GsDrawableHolder.h"
#include "Gi/GiCommonDraw.h"
#include "Gs/GsProperties.h"
#include "Gs/GsCullingVolume.h"
#include "Gs/GsViewLocalId.h"
#include "Gs/GsOverlayDefs.h"
#include "Gi/GiAbstractClipBoundary.h"
#include "ThreadsCounter.h"
 
class OdGsBaseVectorizeDevice;
class OdGeBoundBlock3d;
class OdGiPathNode;
 
struct OdSiShape;
typedef OdArray<const OdSiShape*, OdMemoryAllocator<const OdSiShape*> > OdSiShapeConstPtrArray;
 
class GS_TOOLKIT_EXPORT OdGsViewImpl : public OdGsView
{
public:
  ODRX_DECLARE_MEMBERS(OdGsViewImpl);
 
  OdGsViewImpl();
  
  ~OdGsViewImpl();
 
  // OdGsView methods
 
  virtual void init(OdGsBaseVectorizeDevice* pDevice, 
    const OdGsClientViewInfo* pViewInfo = 0, 
    bool enableLayerVisibilityPerView = false);
 
  virtual OdGsDevice* device() const;
 
  virtual void clientViewInfo(OdGsClientViewInfo& viewInfo) const;
 
  
  virtual RenderMode mode() const;
  
  bool setModeOverride(RenderMode mode);
  
  virtual void setMode(RenderMode mode);
 
  
  virtual void freezeLayer(OdDbStub* layerID);
  
  virtual void thawLayer(OdDbStub* layerID);
  
  virtual void clearFrozenLayers();
 
  
  virtual void setViewportBorderProperties(ODCOLORREF color, int width);
  
  virtual void getViewportBorderProperties(ODCOLORREF& color, int& width) const;
  
  virtual void setViewportBorderVisibility(bool visible);
  
  virtual bool isViewportBorderVisible() const;
 
  
  virtual void setEnableFrontClip(bool enable);
  
  virtual bool isFrontClipped() const;
  
  virtual void setFrontClip(double distance);
  
  virtual double frontClip() const;
 
  virtual void setEnableBackClip(bool enable);
  
  virtual bool isBackClipped() const;
  
  virtual void setBackClip(double distance);
  
  virtual double backClip() const;
 
  
  
  virtual OdGePoint3d position() const;
  
  virtual OdGePoint3d target() const;
  
  virtual OdGeVector3d upVector() const;
  
  virtual double fieldWidth() const;
  
  virtual double fieldHeight() const;
  double windowAspect() const;
 
  virtual double lensLength() const;
  
  virtual void setLensLength(double lensLength);
 
  virtual bool isPerspective() const;
 
  
  
  virtual void beginInteractivity(double frameRateInHz);
  
  virtual bool isInInteractivity() const;
  
  virtual double interactivityFrameRate() const;
  
  virtual void endInteractivity();
  
  virtual void flush();
 
  
  
  virtual void hide();
  
  virtual void show();
  
  virtual bool isVisible();
 
  
  
  virtual OdGsViewPtr cloneView(bool cloneViewParameters = true, bool cloneGeometry = false);
  
  virtual bool exceededBounds();
  
  virtual void enableStereo(bool enabled);
  
  virtual bool isStereoEnabled() const;
  
  virtual void setStereoParameters(double magnitude, double parallax);
  
  virtual void getStereoParameters(double& magnitude, double& parallax) const;
  
  virtual void initLights(OdRxIterator* pLightsIterator);
  
  virtual void getSnapShot(OdGiRasterImagePtr &pImage, const OdGsDCRect &region);
 
  
  
  virtual void setViewport(const OdGePoint2d& lowerLeft, const OdGePoint2d& upperRight);
  
  virtual void setViewport(const OdGsDCRect& screenRect);
  
  virtual void setViewport(const OdGsDCRectDouble& screenRec);
 
  virtual void getViewport(OdGePoint2d& lowerLeft, OdGePoint2d& upperRight) const;
  
  virtual void getViewport(OdGsDCRect& screenRect) const;
  
  virtual void getViewport(OdGsDCRectDouble& screenRec) const;
 
  
  
  virtual OdGeMatrix3d screenMatrix() const;
  
  virtual OdGeMatrix3d worldToDeviceMatrix() const;
  
  virtual OdGeMatrix3d objectToDeviceMatrix() const;
  
  virtual OdGeMatrix3d viewingMatrix() const;
  
  virtual OdGeMatrix3d projectionMatrix() const;
 
  virtual void viewParameters(OdGsView* pView) const;
 
  
  
  virtual double lineweightToDcScale() const;
  
  virtual void setLineweightToDcScale(double scale);
  
  virtual void setLineweightEnum(int numLineweights, const OdUInt8* lineweights);
  
  virtual void setLinetypeScaleMultiplier(double linetypeScaleMultiplier);
  
  virtual void setAlternateLinetypeScaleMultiplier(double linetypeAlternateScaleMultiplier);
  
  virtual double linetypeScaleMultiplier() const;
 
 
 
  virtual void dolly(const OdGeVector3d& dollyVector);
  
  virtual void dolly(double xDolly, double yDolly, double zDolly);
  
  virtual void roll(double rollAngle);
  
  virtual void orbit(double xOrbit, double yOrbit);
  
  virtual void zoom(double zoomFactor);
  
  virtual void pan(double xPan, double yPan);
  
  virtual void setView(const OdGePoint3d & position,
    const OdGePoint3d& target,
    const OdGeVector3d& upVector,
    double fieldWidth,
    double fieldHeight,
    Projection projection = kParallel);
 
  
  
  virtual void zoomExtents(const OdGePoint3d &minPt, const OdGePoint3d &maxPt);
  
  virtual void zoomWindow(const OdGePoint2d &lowerLeft, const OdGePoint2d &upperRight);
  
  virtual bool pointInView(const OdGePoint3d &pt) const;
  
  virtual bool extentsInView(const OdGePoint3d &minPt, const OdGePoint3d &maxPt) const;
 
  
  
  virtual void viewportClipRegion(OdIntArray& counts, OdGePoint2dArray& vertices) const;
  
  virtual void viewportClipRegion(OdIntArray& counts, OdGsDCPointArray& dcPts) const;
  
  virtual void setViewportClipRegion(int numContours, const int* numVertices, const OdGePoint2d* vertices);
  
  virtual void setViewportClipRegion(int numContours, int const* numVertices, OdGsDCPoint const* vertices);
 
  bool isDependentViewportView() const;
  bool isDependentGeometryView() const;
  bool isHelperView() const;
 
  
  const OdGsBaseModule *getGsModulePtr() const;
 
  const OdGiContextualColors *contextualColors() const;
  
  void setContextualColors(OdGiContextualColors *pColors);
 
  virtual bool pointInViewport(const OdGePoint2d& screenPoint) const;
 
  virtual void setClearColor(ClearColor color);
  
  
  
  virtual void invalidate();
  
  virtual void invalidate(const OdGsDCRect &rect);
  
  virtual void invalidateCachedViewportGeometry();
  virtual void select(const OdGsDCPoint* points, int numPoints, OdGsSelectionReactor* pReactor,
    SelectionMode mode = kCrossing);
 
  virtual bool add(OdGiDrawable* sceneGraph, OdGsModel* model);
  
  virtual int numRootDrawables() const;
  
  virtual OdDbStub* rootDrawableIdAt(int i, OdGsModelPtr* pModelReturn = 0) const;
  
  virtual OdGiDrawablePtr rootDrawableAt(int i, OdGsModelPtr* pModelReturn = 0) const;
  
  virtual bool erase(OdGiDrawable* sceneGraph);
  
  virtual void eraseAll();
 
  
  
  virtual OdGsModel *getModel(const OdGiDrawable *pDrawable) const;
  
  virtual OdGsModelArray getModelList() const;
 
  virtual bool isValid() const;
  
  virtual void getNumPixelsInUnitSquare(const OdGePoint3d& givenWorldpt,
    OdGePoint2d& pixelArea, bool includePerspective = true) const;
 
  virtual void setBackground(OdDbStub *backgroundId);
  
  virtual OdDbStub *background() const;
  
  virtual void setVisualStyle(OdDbStub *visualStyleId);
  
  virtual OdDbStub *visualStyle() const;
  
  virtual void setVisualStyle(const OdGiVisualStyle &visualStyle);
  
  virtual bool visualStyle(OdGiVisualStyle &vs) const;
  
  virtual void enableDefaultLighting(bool bEnable, DefaultLightingType lightType = kTwoLights);
  
  bool defaultLightingEnabled() const;
  
  DefaultLightingType defaultLightingType() const;
 
  // OdGsViewImpl methods
 
  static OdGsViewImpl* safeCast(OdGsView* pView);
  
  static const OdGsViewImpl* safeCast(const OdGsView* pView);
 
  OdUInt32 viewportId() const { return m_giViewportId; }
  
  bool isValidViewportId(const OdUInt32 vpId) const;
 
  //NS TODO: rename to viewportObjectId()
  OdDbStub* getViewportObjectId() const { return m_viewInfo.viewportObjectId; }
 
  OdGsBaseVectorizeDevice* baseDevice() { return m_pDevice; }
  
  const OdGsBaseVectorizeDevice* baseDevice() const { return m_pDevice; }
 
  OdDbStub* annotationScaleId() const;
  
  OdIntPtr drawablesFilterFunction() const;
 
  virtual bool viewExtents(OdGeBoundBlock3d& extents) const = 0;
 
  // Own methods
  
  
  virtual void select(const OdGePoint2d* aPtDc, int numPoints, OdGsSelectionReactor* pReactor,
    SelectionMode mode = kCrossing) = 0;
 
  bool isSnapping() const;
  void setSnapping(bool val);
  bool isRegenOnDrawForbidden() const;
  void setRegenOnDrawForbidden(bool val);
  bool isAccumulateVpChanges() const;
  
  virtual void clearLinetypeCache() = 0;
  
  double linetypeAlternateScaleMultiplier() const;
 
  // Legacy plot modes (#12611)
  // Legacy Wireframe
  virtual bool isSupportLegacyWireframeMode() const;
  virtual bool isLegacyWireframeMode() const;
  virtual void setLegacyWireframeMode(bool bSet);
  // Legacy Hidden
  virtual bool isSupportLegacyHiddenMode() const;
  virtual bool isLegacyHiddenMode() const;
  virtual void setLegacyHiddenMode(bool bSet);
  
  bool isSupportPlotStyles() const;
  // Transparencies plotting
  
  virtual bool isPlotTransparency() const;
  
  virtual void setPlotTransparency(bool bSet);
 
  OdUInt32 frozenLayers() const { return m_frozenLayers.size(); }
  
  void frozenLayers(OdDbStubPtrArray& frozenLayers) const { frozenLayers = m_frozenLayers; }
  
  bool isLayerVisible(OdDbStub* layerId) const;
 
  int lineweightToPixels(OdDb::LineWeight lineweight) const;
  
  double lineweightToPixels(double lineweight) const;
 
  void screenRect(OdGsDCPoint &lowerLeft, OdGsDCPoint &upperRight) const;
  
  void screenRect(OdGePoint2d &lowerLeft, OdGePoint2d &upperRight) const;
  
  void screenRectNorm(OdGsDCRect& normalizedRect) const;
  
  void viewportDcCorners(OdGePoint2d& lower_left, OdGePoint2d& upper_right) const;
  
  bool doPerspectivePt(OdGePoint3d& point) const;
  
  bool doInversePerspectivePt(OdGePoint3d& point) const;
 
  const OdGeMatrix3d& eyeToWorldMatrix() const;
  
  const OdGeMatrix3d& worldToEyeMatrix() const;
  
  OdGeMatrix3d eyeToScreenMatrix(OdGsOverlayId nOverlay = kGsMainOverlay) const;
  
  OdGeMatrix3d worldToDeviceMatrix(OdGsOverlayId nOverlay) const;
  
  OdGeMatrix3d objectToDeviceMatrix(OdGsOverlayId nOverlay) const;
  
  enum ProjectionMatrixFlags
  {
    kProjectionIncludeDept        = (1 << 0),
    kProjectionIncludeClip        = (1 << 1),
    kProjectionIncludePerspective = (1 << 2),
    kProjectionIncludeRotation    = (1 << 3),
    kProjectionIncludeAll         = 0x0F,
    kProjectionIncludeAllNoDept   = kProjectionIncludeAll & ~kProjectionIncludeDept
  };
  
  OdGeMatrix3d projectionMatrix(OdUInt32 nIncludes, OdGsOverlayId nOverlay = kGsMainOverlay) const;
 
  ClearColor clearColor() const;
 
  OdGsOverlayId extentsToPixels(OdGsDCRect &rc, const OdGeExtents3d& worldExt, const OdGsBaseModel *pModel, OdDb::LineWeight extendByLineweight = OdDb::kLnWt000) const;
  virtual void invalidate(const OdGeExtents3d& worldExt, const OdGsBaseModel *pModel, OdDb::LineWeight extendByLineweight = OdDb::kLnWt000);
 
  void invalidate(const OdGsUpdateExtents& extents, const OdGsBaseModel *pModel);
  
  void invalidateRegion(const OdGiPathNode& path);
 
  OdGsDCRectArray invalidRects(OdGsOverlayId nOverlay = kGsMainOverlay) const;
  bool isViewportOnScreen() const;
 
  bool isCompletelyVisible() const;
  void setCompletelyVisible(bool val);
 
  void setInversion(bool invertedX, bool invertedY);
 
  virtual OdGiRegenType getRegenType() const { return m_regenerationType; }
 
  double focalLength() const;
 
  const OdGeVector3d& eyeVector() const { return m_eyeVector; }
  
  const OdGeVector3d& xVector() const { return m_xVector; }
  
  const OdGeVector3d& getUpVector() const { return m_upVector; }
 
  double getLinetypeScaleMultiplier() const;
  
  double getLinetypeGenerationCriteria() const;
 
  virtual double getDeviation(const OdGiDeviationType deviationType,
      const OdGePoint3d& pointOnCurve, bool bRecalculate = false) const;
  
  void initDeviation();
 
  int cachedDrawables() const { return m_nCachedDrawables!=0; }
 
  // Local viewport ID section
  OdUInt32 localViewportId(const OdGsBaseModel *pModel) const
  {
    return m_localId.localViewportId(pModel);
  }
  virtual bool isLocalViewportIdCompatible(const OdGsViewImpl *pView) const;
  OdGsViewLocalId &getViewLocalId()
  {
    return m_localId;
  }
 
  virtual bool isViewRegenerated() const;
 
  const OdGePoint2d& center() const;
  void setCenter(const OdGePoint2d& center);
 
  OdGePoint3d focusPoint() const;
protected:
  void getUnrotatedFieldSize(double& fieldWidth, double& fieldHeight) const;
  void getClippingPlanes(double& nearClipPlaneDist, double& farClipPlaneDist
    , OdGsOverlayId overlayId, OdUInt32 projectionFlags) const;
  OdGeMatrix3d projectionMatrix(double nearClipPlaneDist, double farClipPlaneDist
    , OdUInt32 projectionFlags) const;
  OdGeMatrix3d eyeToScreenMatrix(double nearClipPlaneDist, double farClipPlaneDist
    , OdGsOverlayId overlayId) const;
  OdGeMatrix3d screenMatrix(double nearClipPlaneDist, double farClipPlaneDist) const;
 
  virtual bool sceneDept(double& zNear, double& zFar, OdGsOverlayId nOverlay) const;
  // This is old version of sceneDept overrideable method, which is still provided for compatibility with
  // old vectorizers. Don't override it in new vectorizers, use new sceneDept method version even if
  // your vectorizer doesn't support overlay buffers. This method will be removed in one of next ODA Platform versions.
  virtual bool sceneDept(double& zNear, double& zFar) const;
 
  virtual bool usesDept(double* pMinDeptSupported = 0, double* pMaxDeptSupported = 0) const;
protected:
  void onWorldToEyeChanged();
 
  void onFinalRelease();
 
  virtual void updateViewProps(bool bFullUpdate = true);
 
  inline bool isCheckValid() const;
  inline void setCheckValid(bool bValue) const;
  inline bool isInvalid() const;
  inline void setInvalid(bool bValue) const;
  inline void setPerspectiveEnabled(bool bValue) const;
  inline void setAccumulateVpChanges( bool bSet );
public:
  inline bool isNonRectClipped() const;
  
  inline bool hasLweights() const { return !m_lweights.empty(); }
  
  inline const OdUInt8Array &getLweightsEnum() const { return m_lweights; }
 
  const OdGePoint2d& dcScreenMin() const { return m_dcScreenMin; }
  
  const OdGePoint2d& dcScreenMax() const { return m_dcScreenMax; }
  
  const OdGePoint2d& dcLowerLeft() const { return m_dcLowerLeft; }
  
  const OdGePoint2d& dcUpperRight() const { return m_dcUpperRight; }
 
  OdGeMatrix3d perspectiveMatrix() const;
 
  static double lensLengthToFOV(double lensLength);
  static double lensLengthFromFOV(double fovAngle);
 
  void invalidateCachedViewportGeometry(OdUInt32 mask);
 
  virtual void registerOverlay(const OdGsModel *pModel);
 
  virtual void unregisterOverlay(const OdGsModel *pModel);
 
  virtual int partialUpdateExtentsEnlargement() const;
protected:
  OdGiDrawablePtr drawableAt(DrawableHolder& drawableHolder);
  OdGsNode* getRootNode(DrawableHolder& holder);
  virtual void propagateInvalidVpFlag();
  virtual void propagateLayersChanges();
 
public:
  double calcDeviation(const OdGiDeviationType type, const OdGePoint3d& pt) const;
 
  // Viewport properties (backgrounds, render settings, visual styles) management
  
  OdGsPropertiesPtr getViewportPropertiesRoot() const;
  
  bool updateViewportProperties(OdUInt32 incFlags);
  
  OdGsPropertiesPtr getViewportPropertiesForType(OdGsProperties::PropertiesType type) const;
 
  // Printing support methods
 
  const OdGeMatrix3d& rotationMatrix() const;
  
  short viewportRotation() const;
  
  inline bool isRotated() const;
 
  double unrotatedFieldHeight() const;
  
  double unrotatedFieldWidth() const;
 
  double actualFieldWidth() const;
  double actualFieldHeight() const;
 
  // Primitives culling routines
 
  virtual void initCullingVolume();
  void setCullingVolume(OdGsCullingVolumePtr newVol);
  OdGsCullingVolumePtr cullingVolume() const;
  virtual bool isCullingVolumeInitialized() const;
  virtual bool cullingVolumeIntersectWithOpt(const OdGsCullingPrimitive &prim) const;
  virtual OdGsCullingVolume::IntersectionStatus cullingVolumeIntersectWith(const OdGsCullingPrimitive &prim) const;
  virtual void cullingVolumeTransformBy(const OdGeMatrix3d &xfm);
 
  virtual void setViewport3dClipping(const OdGiClipBoundary* pBoundary, const OdGiAbstractClipBoundary* pClipInfo = NULL);
  virtual const OdGiClipBoundary *viewport3dClipping(const OdGiAbstractClipBoundary** ppClipInfo = NULL) const;
  OdGiClipBoundaryWithAbstractData *viewport3dClippingObject();
  bool hasViewport3dClipping() const;
 
  virtual bool saveViewState(OdGsFiler *pFiler) const;
  
  virtual bool loadViewState(OdGsFiler *pFiler);
  
  virtual bool saveClientViewState(OdGsFiler *pFiler) const;
  
  virtual bool loadClientViewState(OdGsFiler *pFiler);
 
  virtual const OdDbStubPtrArray& getFrozenLayersDiff() const;
 
  virtual void collide( OdGiPathNode const*const* pInputList, OdUInt32 nInputListSize, OdGsCollisionDetectionReactor* pReactor,
                        OdGiPathNode const*const* pCollisionWithList = NULL, OdUInt32 nCollisionWithListSize = 0,
                        const OdGsCollisionDetectionContext* pCtx = NULL ) = 0;
 
  virtual void enableAntiAliasing(OdUInt32 nMode);
 
  virtual OdUInt32 antiAliasingMode() const;
 
  virtual void enableSSAO(bool bEnable) ODRX_OVERRIDE;
 
  virtual bool ssaoMode() const ODRX_OVERRIDE;
 
  void addClippingShape(const OdSiShape*);
  
  void removeClippingShape(const OdSiShape*);
  
  const OdSiShapeConstPtrArray& clippingShapes() const;
  
  void setClippingShapes(const OdSiShapeConstPtrArray& s);
private:
  void setExtents(OdGsOverlayId nOverlay, const OdGeExtents3d& ext, bool bAdd, bool bVisible = true);
  void getExtents(OdGsOverlayId nOverlay, OdGeExtents3d& ext, bool bVisible = false) const;
 
  void addInvalidRectThisView(OdGsOverlayId nOverlay, const OdGsDCRect& rc, const OdGsDCRect& vpRc);
 
private:
  enum EGsViewImplFlags
  {
    kFirstViewImplFlag       = 1,
 
    kInvalid                 = kFirstViewImplFlag << 0, // device surface entirely invalid
    kCheckValid              = kFirstViewImplFlag << 1, // device surface entirely valid
    kBorderVisible           = kFirstViewImplFlag << 2,
    kDoFrontClip             = kFirstViewImplFlag << 3,
    kDoBackClip              = kFirstViewImplFlag << 4,
    kPerspectiveEnabled      = kFirstViewImplFlag << 5,
    kHidden                  = kFirstViewImplFlag << 6, // view is hidden
    kTransparentClearColor   = kFirstViewImplFlag << 7,
    kDevBgClearColor         = kFirstViewImplFlag << 8,
    kEyeToWorldValid         = kFirstViewImplFlag << 9,
    kWorldToEyeValid         = kFirstViewImplFlag << 10,
    kSnapping                = kFirstViewImplFlag << 11,
    kForbidDrawableRegenDraw = kFirstViewImplFlag << 12,
    kDepViewInside           = kFirstViewImplFlag << 13,
    kLegacyWireframe         = kFirstViewImplFlag << 14,
    // there are two modes with hidden lines removed:
    // - normal, set by SHADEMODE command in CAD for display and
    //   represented by 'Hidden' visual style in shade plot viewport/layout props for printing, and
    // - legacy, set by HIDE command in CAD for display and
    //   according to 'OdDbViewport/OdDbPlotSettings::kHidden' shade plot for printing;
    // they both use 'kHiddenLine' render mode, but have some differences, e.g. in plot style usage;
    // this flag is to distinguish these two cases
    kLegacyHidden            = kFirstViewImplFlag << 15,
    kPlotTransparency        = kFirstViewImplFlag << 16,
    kAccumulateVpChanges     = kFirstViewImplFlag << 17,
    kDefaultLightingEnabled  = kFirstViewImplFlag << 18,
    kSSAOEnabled             = kFirstViewImplFlag << 19
  };
protected:
  OdDbStubPtrArray m_lastFrozenLayers;
protected: //FELIX_CHANGE
  OdGsBaseModulePtr m_pModule;
  OdDbStubPtrArray m_frozenLayersDiff;
 
  mutable OdUInt32 m_gsViewImplFlags;
  ODCOLORREF m_borderColor;
  int m_borderWeight;
  double m_frontClipDist;
  double m_backClipDist;
  bool m_screenInvertedX;
  bool m_screenInvertedY;
  OdGePoint2d m_dcScreenMin;
  OdGePoint2d m_dcScreenMax;
  OdGePoint2d m_dcLowerLeft;
  OdGePoint2d m_dcUpperRight;
 
  double m_fieldWidth;
  double m_fieldHeight;
  double m_lensLength;
  double m_eyeVecLength;
 
  OdGePoint3d m_position;
  OdGePoint3d m_target;
  OdGeVector3d m_upVector;
  OdGeVector3d m_eyeVector;
  OdGeVector3d m_xVector;
  OdGePoint2d m_center;
  mutable OdGeMatrix3d m_eyeToWorld;
  mutable OdGeMatrix3d m_worldToEye;
 
  OdIntArray m_nrcCounts;
  OdGePoint2dArray m_nrcPoints;
  double m_linetypeScaleMultiplier;
  double m_linetypeAlternateScaleMultiplier;
  double m_lineweightToDcScale;
  OdUInt8Array m_lweights;
  OdGsCullingVolumePtr m_pCullingVolume;
  OdSharedPtr<OdGiClipBoundaryWithAbstractData> m_p3dClip;
  OdSiShapeConstPtrArray m_clippingShapes;
 
  double m_deviation[5];
 
  int m_nCachedDrawables;
  mutable OdMutexPtr m_mtExtents;
 
  OdGsPropertiesPtr m_pProperties;
  OdDbStub *m_pBackgroundId;
  OdDbStub *m_pVisualStyleId;
  OdGiDrawablePtr m_pViewportTrans;
  DefaultLightingType m_defaultLightingType;
  OdUInt32 m_antiAliasingMode;
 
protected:
  struct GsViewOverlayData
  {
    enum OverlayFlags
    {
      kWorldToDeviceValid = (1 << 0),
      kSceneDeptInvalid   = (1 << 1),
      kViewToScreenValid  = (1 << 2)
    };
    mutable OdUInt32 m_nOverlayFlags;
    mutable OdGeMatrix3d m_worldToDeviceMatrix;
    mutable OdGeMatrix3d m_viewToScreenMat;
    mutable double m_nearClipPlaneDist1;
    mutable double m_farClipPlaneDist1;
    mutable double m_nearClipPlaneDist2;
    mutable double m_farClipPlaneDist2;
    OdGeExtents3d m_extents, m_viewExtents;
    OdGsDCRectArray m_invalidRects;
    GsViewOverlayData()
      : m_nOverlayFlags(0)
      , m_nearClipPlaneDist1(0.0)
      , m_farClipPlaneDist1(0.0)
      , m_nearClipPlaneDist2(0.0)
      , m_farClipPlaneDist2(0.0)
    {}
  };
  class GS_TOOLKIT_EXPORT GsViewOverlayDataContainer : public OdGsOverlayDataContainer<GsViewOverlayData>
  {
    public:
      void setWorldToDeviceInvalid();
      void setSceneDeptInvalid(OdGsOverlayId nOverlay, bool bSet) const;
      void clearInvalidRects(OdUInt32 nOverlays = kGsAllOverlays);
      bool hasInvalidRects(OdUInt32 nOverlays = kGsAllOverlays) const;
  };
  mutable GsViewOverlayDataContainer m_overlayData;
protected:
  OdGsBaseVectorizeDevice* m_pDevice;
  OdGsClientViewInfo m_viewInfo;
  OdUInt32 m_giViewportId;
  OdGsViewLocalId m_localId;
  OdGiRegenType m_regenerationType;
  // Reserved pointer for internal use (binary incompatible changes), do not delete.
  OdRxObjectPtr m_pGsReserved;
 
  // Made protected for access in OdGiViewport methods
  RenderMode m_renderMode;
 
  DrawableHolderArray m_drawables;
 
  OdDbStubPtrArray m_frozenLayers;
 
  bool m_bInInteractivityMode;
  double m_dInteractivityFrameRate;
 
  friend class GsViewImplHelper;
  friend class OdGiBaseVectorizerImpl;
  friend class OdGsBaseVectorizer;
  friend class OdGsBaseModule;
  friend class OdGsBaseVectorizeDevice;
};
 
inline bool OdGsViewImpl::isDependentViewportView() const
{
  return GETBIT(m_viewInfo.viewportFlags, OdGsClientViewInfo::kDependentViewport);
}
 
inline bool OdGsViewImpl::isDependentGeometryView() const
{
  return GETBIT(m_viewInfo.viewportFlags, OdGsClientViewInfo::kDependentGeometry);
}
 
inline bool OdGsViewImpl::isHelperView() const
{
  return GETBIT(m_viewInfo.viewportFlags, OdGsClientViewInfo::kHelperView);
}
 
inline const OdGsBaseModule *OdGsViewImpl::getGsModulePtr() const
{
  return m_pModule.get();
}
 
inline const OdGiContextualColors *OdGsViewImpl::contextualColors() const
{
  return m_viewInfo.contextColors.get();
}
 
inline void OdGsViewImpl::setContextualColors(OdGiContextualColors *pColors)
{
  m_viewInfo.contextColors = pColors;
  invalidate();
}
 
inline bool OdGsViewImpl::isSupportPlotStyles() const
{
  return (mode() == k2DOptimized) || isLegacyHiddenMode() || isLegacyWireframeMode();
}
 
inline bool OdGsViewImpl::isCheckValid() const
{
  return GETBIT(m_gsViewImplFlags, kCheckValid);
}
 
inline void OdGsViewImpl::setCheckValid(bool bValue) const
{
  SETBIT(m_gsViewImplFlags, kCheckValid, bValue);
}
 
inline bool OdGsViewImpl::isInvalid() const
{
  return GETBIT(m_gsViewImplFlags, kInvalid);
}
 
inline void OdGsViewImpl::setInvalid(bool bValue) const
{
  SETBIT(m_gsViewImplFlags, kInvalid, bValue);
}
 
inline void OdGsViewImpl::setPerspectiveEnabled(bool bValue) const
{
  SETBIT(m_gsViewImplFlags, kPerspectiveEnabled, bValue);
  if (bValue != isPerspective())
    m_overlayData.setWorldToDeviceInvalid();
}
 
inline bool OdGsViewImpl::defaultLightingEnabled() const
{
  return GETBIT(m_gsViewImplFlags, kDefaultLightingEnabled);
}
 
inline OdGsView::DefaultLightingType OdGsViewImpl::defaultLightingType() const
{
  return m_defaultLightingType;
}
 
inline void OdGsViewImpl::enableAntiAliasing(OdUInt32 nMode)
{
  if (antiAliasingMode() != nMode)
  {
    m_antiAliasingMode = nMode;
    invalidate();
  }
}
 
inline OdUInt32 OdGsViewImpl::antiAliasingMode() const
{
  return m_antiAliasingMode;
}
 
inline void OdGsViewImpl::enableSSAO(bool bEnable)
{
  if (ssaoMode() != bEnable)
  {
    SETBIT(m_gsViewImplFlags, kSSAOEnabled, bEnable);
    invalidate();
  }
}
 
inline bool OdGsViewImpl::ssaoMode() const
{
  return GETBIT(m_gsViewImplFlags, kSSAOEnabled);
}
 
inline bool OdGsViewImpl::isNonRectClipped() const
{
  return m_nrcCounts.size() != 0;
}
 
inline bool OdGsViewImpl::isRotated() const
{
  short rotation = viewportRotation();
  return rotation == 90 || rotation == 270;
}
 
inline void OdGsViewImpl::invalidate(const OdGsUpdateExtents& extents, const OdGsBaseModel *pModel)
{
  invalidate(extents.getExtents(), pModel, extents.getLineweight());
}
 
inline const OdGeMatrix3d& OdGsViewImpl::eyeToWorldMatrix() const
{
  if(!GETBIT(m_gsViewImplFlags, kEyeToWorldValid))
  {
    m_eyeToWorld.setCoordSystem(target(), xVector(), upVector(), eyeVector());
    SETBIT(m_gsViewImplFlags, kEyeToWorldValid, true);
  }
  return m_eyeToWorld;
}
 
inline const OdGeMatrix3d& OdGsViewImpl::worldToEyeMatrix() const
{
  if(!GETBIT(m_gsViewImplFlags, kWorldToEyeValid))
  {
    m_worldToEye = eyeToWorldMatrix().inverse();
    SETBIT(m_gsViewImplFlags, kWorldToEyeValid, true);
  }
  return m_worldToEye;
}
 
inline OdGsViewImpl* OdGsViewImpl::safeCast(OdGsView* pView)
{
  return OdSmartPtr<OdGsViewImpl>(pView).get();
}
 
inline const OdGsViewImpl* OdGsViewImpl::safeCast(const OdGsView* pView)
{
  return OdSmartPtr<OdGsViewImpl>(pView).get();
}
 
inline bool OdGsViewImpl::isSnapping() const
{
  return GETBIT(m_gsViewImplFlags, kSnapping);
}
 
inline void OdGsViewImpl::setSnapping(bool val)
{
  SETBIT(m_gsViewImplFlags, kSnapping, val);
}
 
inline bool OdGsViewImpl::isRegenOnDrawForbidden() const
{
  return GETBIT(m_gsViewImplFlags, kForbidDrawableRegenDraw);
}
 
inline void OdGsViewImpl::setRegenOnDrawForbidden(bool val)
{
  SETBIT(m_gsViewImplFlags, kForbidDrawableRegenDraw, val);
}
 
inline bool OdGsViewImpl::isAccumulateVpChanges() const
{
  return GETBIT(m_gsViewImplFlags, kAccumulateVpChanges);
}
 
inline void OdGsViewImpl::setAccumulateVpChanges( bool bSet )
{
  SETBIT( m_gsViewImplFlags, kAccumulateVpChanges, bSet );
}
 
inline bool OdGsViewImpl::isCompletelyVisible() const
{
  return GETBIT(m_gsViewImplFlags, kDepViewInside);
}
 
inline void OdGsViewImpl::setCompletelyVisible(bool val)
{
  SETBIT(m_gsViewImplFlags, kDepViewInside, val);
}
 
inline OdGiClipBoundaryWithAbstractData *OdGsViewImpl::viewport3dClippingObject()
{
  return m_p3dClip.get();
}
 
inline bool OdGsViewImpl::hasViewport3dClipping() const
{
  return !m_p3dClip.isNull();
}
 
inline double OdGsViewImpl::actualFieldWidth() const
{
  return m_fieldWidth;
}
 
inline double OdGsViewImpl::actualFieldHeight() const
{
  return m_fieldHeight;
}
 
inline void OdGsViewImpl::addClippingShape(const OdSiShape* p)
{
  if (!m_clippingShapes.contains(p))
    m_clippingShapes.append(p);
}
 
inline void OdGsViewImpl::removeClippingShape(const OdSiShape* p)
{
  OdSiShapeConstPtrArray::size_type i;
  if (m_clippingShapes.find(p, i, 0))
    m_clippingShapes.removeAt(i);
}
 
inline const OdSiShapeConstPtrArray& OdGsViewImpl::clippingShapes() const
{
  return m_clippingShapes;
}
 
inline void OdGsViewImpl::setClippingShapes(const OdSiShapeConstPtrArray& s)
{
  m_clippingShapes = s;
}
 
GS_TOOLKIT_EXPORT double calcFocalLength(double lensLength, double fieldWidth, double fieldHeight);
 
#include "TD_PackPop.h"
 
#endif // ODGSVIEWIMPL_INC