Gs.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 __GS_H_INCLUDED_
#define __GS_H_INCLUDED_
 
#include "RxObject.h"
#include "RxIterator.h"
#include "Gs/GsExport.h"
 
class OdGiDrawable;
 
typedef OdSmartPtr<OdGiDrawable> OdGiDrawablePtr;
 
class OdGeMatrix3d;
class OdGePoint3d;
class OdGeVector3d;
class OdGePoint2d;
class OdGiEdgeData;
class OdGiFaceData;
class OdGiVertexData;
struct OdGiClipBoundary;
class OdGiAbstractClipBoundary;
class OdDbStub;
class OdGeExtents3d;
class OdGiVisualStyle;
 
#include "TD_PackPush.h"
 
#include "OdPlatform.h"
#include "RxModule.h"
#include "IntArray.h"
#include "GsDCPointArray.h"
#include "Ge/GePoint2dArray.h"
 
class OdGsSelectionReactor;
 
class OdGsView;
 
typedef OdSmartPtr<OdGsView> OdGsViewPtr;
 
class OdGsModel;
 
typedef OdSmartPtr<OdGsModel> OdGsModelPtr;
 
typedef OdArray<OdGsModel*, OdMemoryAllocator<OdGsModel*> > OdGsModelArray;
 
class OdGsDevice;
 
typedef OdSmartPtr<OdGsDevice> OdGsDevicePtr;
 
class OdRxDictionary;
 
typedef OdSmartPtr<OdRxDictionary> OdRxDictionaryPtr;
 
class OdGsReactor;
 
typedef OdSmartPtr<OdGsReactor> OdGsReactorPtr;
 
class OdGiRasterImage;
 
typedef OdSmartPtr<OdGiRasterImage> OdGiRasterImagePtr;
 
class OdGsUpdateManager;
typedef OdSmartPtr<OdGsUpdateManager> OdGsUpdateManagerPtr;
 
#include "GsDefs.h"
 
class OdGiContext;
struct OdGsClientViewInfo;
class OdGsFiler;
 
class OdGsCollisionDetectionReactor;
class OdGsCollisionDetectionContext;
class OdGiPathNode;
 
#include "Gi/GiContextualColors.h"
 
class FIRSTDLL_EXPORT OdGsView : public OdRxObject
{
public:
  ODRX_DECLARE_MEMBERS(OdGsView);
  
  enum RenderMode
  {
    kBoundingBox                  = -1,     // Bounding box. For internal use only.
    k2DOptimized                  = 0,      // Standard *display*. Optimized for 2D.
    kWireframe                    = 1,      // Standard *display*. Uses 3D pipeline.
    kHiddenLine                   = 2,      // Wireframe *display*. Hidden lines removed.
    kFlatShaded                   = 3,      // Faceted *display*. One *color* per face.
    kGouraudShaded                = 4,      // Smooth shaded *display*. Colors interpolated between *vertices*.
    kFlatShadedWithWireframe      = 5,      // Faceted *display* with wireframe overlay.
    kGouraudShadedWithWireframe   = 6,      // Smooth shaded *display* with wireframe overlay.
    kNone
  };
 
  enum Projection
  {
    kParallel     = 0, // Orthogonal projection.
    kPerspective  = 1  // Perspective projection.
  };
 
  enum SelectionMode
  {
    kWindow       = 0, // Selection by two points (represents rectangle). Select only objects which is entirely inside selection area.
    kCrossing     = 1, // Selection by two points (represents rectangle). Select objects which is entirely inside or intersects selection area.
    kFence        = 2, // Selection by two or more points (represents polyline). Select object which is intersects selection polyline.
    kWPoly        = 3, // Selection by three or more points (represents polygon). Select only objects which is entirely inside selection area.
    kCPoly        = 4, // Selection by three or more points (represents polygon). Select objects which is entirely inside or intersects selection area.
 
    kPoint        = 16 // Same as kCrossing, but returns only single selected object: top for 3D render modes or first for 2D render mode.
  };
 
  enum DefaultLightingType
  {
    kOneLight = 0, // Single front light.
    kTwoLights,    // Front and back lights.
    kBackLight     // Single back light.
  };
 
  enum ViewUpdateFlags
  {
    kCameraChanged = 1
  };
 
  virtual OdGsDevice* device() const = 0;
 
  virtual OdGiContext* userGiContext() const = 0;
 
  virtual void setUserGiContext(OdGiContext* pUserGiContext) = 0;
 
  virtual double lineweightToDcScale() const = 0;
  virtual void setLineweightToDcScale(double scale) = 0;
 
  virtual void setLineweightEnum(int numLineweights, const OdUInt8* lineweights) = 0;
 
  virtual void setViewport(const OdGePoint2d& lowerLeft, const OdGePoint2d& upperRight) = 0;
  
  virtual void setViewport(const OdGsDCRect& screenRect) = 0;
  
  virtual void setViewport(const OdGsDCRectDouble& screenRect);
 
  virtual void getViewport(OdGePoint2d& lowerLeft, OdGePoint2d& upperRight) const = 0;
  
  virtual void getViewport(OdGsDCRect& screenRect) const = 0;
  
  virtual void getViewport(OdGsDCRectDouble& screenRect) const;
 
  virtual void setViewportClipRegion(int numContours, int const* numVertices, OdGsDCPoint const* vertices) = 0;
  
  virtual void setViewportClipRegion(int numContours, int const* numVertices, OdGePoint2d const* vertices) = 0;
 
  virtual void viewportClipRegion(OdIntArray& counts, OdGsDCPointArray& vertices) const = 0;
  
  virtual void viewportClipRegion(OdIntArray& counts, OdGePoint2dArray& vertices) const = 0;
 
  void removeViewportClipRegion();
 
  virtual void setViewport3dClipping(const OdGiClipBoundary* pBoundary, const OdGiAbstractClipBoundary* pClipInfo = NULL);
 
  virtual const OdGiClipBoundary *viewport3dClipping(const OdGiAbstractClipBoundary** ppClipInfo = NULL) const;
 
  void removeViewport3dClipping();
 
  virtual void setViewportBorderProperties(ODCOLORREF color, int width) = 0;
 
  virtual void getViewportBorderProperties(ODCOLORREF& color, int& width) const = 0;
 
  virtual void setViewportBorderVisibility(bool visible) = 0;
 
  virtual bool isViewportBorderVisible() const = 0;
 
  virtual void setView(
    const OdGePoint3d& position,
    const OdGePoint3d& target,
    const OdGeVector3d& upVector,
    double fieldWidth,
    double fieldHeight,
    Projection projectionType = kParallel) = 0;
 
  virtual OdGePoint3d position() const = 0;
 
  virtual OdGePoint3d target() const = 0;
 
  virtual OdGeVector3d upVector() const = 0;
 
  virtual double lensLength() const = 0;
 
  virtual void setLensLength(double lensLength) = 0;
 
  virtual bool isPerspective() const = 0;
 
  virtual double fieldWidth() const = 0;
  virtual double fieldHeight() const = 0;
 
  virtual void setEnableFrontClip(bool enable) = 0;
 
  virtual bool isFrontClipped() const = 0;
 
  virtual void setFrontClip(double frontClip) = 0;
 
  virtual double frontClip() const = 0;
 
  virtual void setEnableBackClip(bool enable) = 0;
 
  virtual bool isBackClipped() const = 0;
 
  virtual void setBackClip(double backClip) = 0;
  virtual double backClip() const = 0;
 
  virtual OdGeMatrix3d viewingMatrix() const = 0;
 
  virtual OdGeMatrix3d projectionMatrix() const = 0;
 
  virtual OdGeMatrix3d screenMatrix() const = 0;
 
  virtual OdGeMatrix3d worldToDeviceMatrix() const = 0;
 
  virtual OdGeMatrix3d objectToDeviceMatrix() const = 0;
 
  virtual void setMode(RenderMode mode) = 0;
 
  virtual RenderMode mode() const = 0;
 
  virtual bool add(OdGiDrawable* pSceneGraph, OdGsModel* pModel) = 0;
 
  virtual int numRootDrawables() const = 0;
 
  virtual OdDbStub* rootDrawableIdAt(int i, OdGsModelPtr* pModelReturn = 0) const = 0;
 
  virtual OdGiDrawablePtr rootDrawableAt(int i, OdGsModelPtr* pModelReturn = 0) const = 0;
 
  virtual bool erase(OdGiDrawable* sceneGraph) = 0;
  virtual void eraseAll() = 0;
 
  virtual OdGsModel *getModel(const OdGiDrawable *pDrawable) const = 0;
  virtual OdGsModelArray getModelList() const = 0;
 
  virtual void invalidate() = 0;
  
  virtual void invalidate(const OdGsDCRect &screenRect) = 0;
 
  virtual bool isValid() const = 0;
 
  virtual void update() = 0;
 
  virtual void beginInteractivity(double frameRateInHz) = 0;
  virtual bool isInInteractivity() const = 0;
  virtual double interactivityFrameRate() const = 0;
  virtual void endInteractivity() = 0;
  virtual void flush() = 0;
 
  virtual void hide() = 0;
 
  virtual void show() = 0;
 
  virtual bool isVisible() = 0;
 
  virtual void freezeLayer(OdDbStub* layerID) = 0;
 
  virtual void thawLayer(OdDbStub* layerID) = 0;
 
  virtual void clearFrozenLayers() = 0;
 
  virtual void invalidateCachedViewportGeometry() = 0;
 
  virtual void select(const OdGsDCPoint* pts, int nPoints,
    OdGsSelectionReactor* pReactor,
    OdGsView::SelectionMode mode = OdGsView::kCrossing) = 0;
 
  virtual void dolly(const OdGeVector3d& dollyVector) = 0;
  
  virtual void dolly(double xDolly, double yDolly, double zDolly) = 0;
 
  virtual void roll(double rollAngle) = 0;
 
  virtual void orbit(double xOrbit, double yOrbit) = 0;
 
  virtual void zoom(double zoomFactor) = 0;
 
  virtual void pan(double xPan, double yPan) = 0;
 
  virtual void zoomExtents(const OdGePoint3d &minPt, const OdGePoint3d &maxPt) = 0;
 
  virtual void zoomWindow(const OdGePoint2d &lowerLeft, const OdGePoint2d &upperRight) = 0;
 
  virtual bool pointInView(const OdGePoint3d &pt) const = 0;
 
  virtual bool extentsInView(const OdGePoint3d &minPt, const OdGePoint3d &maxPt) const = 0;
 
  virtual OdGsViewPtr cloneView(bool cloneViewParameters = true, bool cloneGeometry = false) = 0;
 
  virtual void viewParameters(OdGsView* pView) const = 0;
 
  virtual bool exceededBounds() = 0;
 
  virtual void enableStereo(bool enabled) = 0;
 
  virtual bool isStereoEnabled() const = 0;
 
  virtual void setStereoParameters(double magnitude, double parallax) = 0;
 
  virtual void getStereoParameters(double& magnitude, double& parallax) const = 0;
 
  virtual void initLights(OdRxIterator* pLightsIterator) = 0;
 
  virtual void setLinetypeScaleMultiplier(double linetypeScaleMultiplier) = 0;
 
  virtual double linetypeScaleMultiplier() const = 0;
 
  virtual void setAlternateLinetypeScaleMultiplier(double linetypeAlternateScaleMultiplier) = 0;
 
  virtual double linetypeAlternateScaleMultiplier() const = 0;
 
  virtual void clientViewInfo(OdGsClientViewInfo& clientViewInfo) const;
 
  enum ClearColor
  {
    kTransparent,         // Transparent color
    kDeviceBackground,    // Color from device background
    kPaletteBackground    // Palette background color
  };
 
  virtual void setClearColor(ClearColor color) = 0;
 
  virtual bool pointInViewport(const OdGePoint2d& screenPoint) const = 0;
 
  virtual void getNumPixelsInUnitSquare(const OdGePoint3d& point,
                                        OdGePoint2d& pixelDensity, bool bUsePerspective = true) const = 0;
 
  virtual void setBackground(OdDbStub *backgroundId) = 0;
  virtual OdDbStub *background() const = 0;
 
  virtual void setVisualStyle(OdDbStub *visualStyleId) = 0;
  virtual OdDbStub *visualStyle() const = 0;
  virtual void setVisualStyle(const OdGiVisualStyle &visualStyle) = 0;
  virtual bool visualStyle(OdGiVisualStyle &visualStyle) const = 0;
 
  virtual void enableDefaultLighting(bool bEnable, DefaultLightingType lightType = kTwoLights) = 0;
 
  virtual void getSnapShot(OdGiRasterImagePtr &pImage, const OdGsDCRect &region) = 0;
 
  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) = 0;
  virtual OdUInt32 antiAliasingMode() const = 0;
 
  virtual void enableSSAO(bool bEnable) = 0;
  virtual bool ssaoMode() const = 0;
};
 
struct OdGsClientViewInfo 
{
  enum ViewportFlags
  {
    kDependentViewport = 1,
    kDependentGeometry = 2,
    kHelperView        = 4,
    kSetViewportId     = 8
  };
 
  long      viewportId;        // Returned by OdGiViewport::viewportId()
  long      acadWindowId;      // Returned by OdGiViewport::acadWindowId()
  OdDbStub* viewportObjectId;  // Returned by OdGiViewportDraw::viewportObjectId()
  OdGiContextualColorsPtr contextColors; // Returned by OdGiViewport::contextualColors()
  OdUInt32  viewportFlags;     // Optional view flags
 
  OdGsClientViewInfo()
    : viewportId(-1)
    , acadWindowId(0)
    , viewportObjectId(NULL)
    , viewportFlags(0)
  {
  }
};
 
class OdGsCollisionDetectionReactor
{
public:
  enum
  {
    kNotImplemented = 0x80000000,
    kContinue       = 0,
    kBreak          = 1
  };
  virtual OdUInt32 collisionDetected(const OdGiPathNode* /*pPathNode1*/, const OdGiPathNode* /*pPathNode2*/)
  {
    return OdUInt32(kNotImplemented);
  }
 
  virtual OdUInt32 collisionDetected( const OdGiPathNode* pPathNode1, const OdGiPathNode* pPathNode2, double dDistance )
  {
    return collisionDetected( pPathNode1, pPathNode2 );
  }
};
 
class OdGsCollisionDetectionContext
{
//DOM-IGNORE-BEGIN
protected:
  OdUInt8 m_flags;
  OdGeTol m_tolerance;
  enum Options
  {
    kIntersectionOnly = 1,
    kIntersectionWithModel = 1 << 1,
    kIgnoreViewExtents = 1 << 2,
    kCombineSubEntities = 1 << 3,
    kOverrideTolerance = 1 << 4,
    kCalculateDistance = 1 << 5,
    kCheckAll = 1 << 6,
    kProcessSingleList = 1 << 7
  };
  double m_clearance;
//DOM-IGNORE-END
public:
  OdGsCollisionDetectionContext() : m_flags( kCalculateDistance ) { m_tolerance = OdGeTol(); m_clearance = 0.0; };
 
  void setIntersectionOnly( bool bSet ) { SETBIT( m_flags, kIntersectionOnly, bSet ); }
  
  bool intersectionOnly() const { return GETBIT( m_flags, kIntersectionOnly ); }
 
  void setIntersectionWithModel( bool bSet ) { SETBIT( m_flags, kIntersectionWithModel, bSet ); }
  
  bool intersectionWithModel() const { return GETBIT( m_flags, kIntersectionWithModel ); }
 
  void setIgnoreViewExtents( bool bSet ) { SETBIT( m_flags, kIgnoreViewExtents, bSet ); }
  
  bool ignoreViewExtents() const { return GETBIT( m_flags, kIgnoreViewExtents ); }
  void setCombineSubEntities( bool bSet ) { SETBIT( m_flags, kCombineSubEntities, bSet ); }
  bool combineSubEntities() const { return GETBIT( m_flags, kCombineSubEntities ); }
  void setToleranceOverride( const OdGeTol& tol )
  {
    SETBIT_1( m_flags, kOverrideTolerance );
    m_tolerance = tol;
  }
  bool isToleranceOverride() const { return GETBIT( m_flags, kOverrideTolerance ); }
  const OdGeTol& toleranceOverride() const { return m_tolerance; }
  void setCalculateDistance( bool bSet ) { SETBIT( m_flags, kCalculateDistance, bSet ); }
  bool getCalculateDistance() const { return GETBIT( m_flags, kCalculateDistance ); }
  void setCheckAll( bool bSet ) { SETBIT( m_flags, kCheckAll, bSet ); }
  bool getCheckAll() const { return GETBIT( m_flags, kCheckAll ); }
  void setClearance( double c ) { m_clearance = c; }
  double getClearance() const { return m_clearance; }
  void setProcessSignleList( bool bSet ) { SETBIT( m_flags, kProcessSingleList, bSet ); }
  bool getProcessSignleList() const { return GETBIT( m_flags, kProcessSingleList ); }
 
};
 
class OdGiContext;
 
class FIRSTDLL_EXPORT OdGsDevice : public OdRxObject
{
public:
  ODRX_DECLARE_MEMBERS(OdGsDevice);
 
  virtual OdRxDictionaryPtr properties() = 0;
 
  virtual OdGiContext* userGiContext() const = 0;
 
  virtual void setUserGiContext(OdGiContext* pUserGiContext) = 0;
 
  virtual void invalidate() = 0;
 
  virtual void invalidate(const OdGsDCRect &screenRect) = 0;
 
  virtual bool isValid() const = 0;
 
  virtual void update(OdGsDCRect* pUpdatedRect = 0) = 0;
 
  virtual void onSize(const OdGsDCRect& outputRect) = 0;
  
  virtual void onSize(const OdGsDCRectDouble& outputRect);
 
  virtual void getSize(OdGsDCRect& outputRect) const = 0;
  
  virtual void getSize(OdGsDCRectDouble& outputRect) const;
 
    virtual void onRealizeForegroundPalette() = 0;
 
    virtual void onRealizeBackgroundPalette() = 0;
 
  virtual void onDisplayChange(int bitsPerPixel, int xPixels, int yPixels) = 0;
 
  virtual OdGsViewPtr createView(
    const OdGsClientViewInfo* pViewInfo = 0, 
    bool enableLayerVisibilityPerView = false) = 0;
 
  virtual void addView(OdGsView* pView) = 0;
 
  virtual OdGsModelPtr createModel() = 0;
 
  virtual bool isModelCompatible(OdGsModel* pModel) const;
 
  virtual bool saveDeviceState(OdGsFiler *pFiler) const;
  virtual bool loadDeviceState(OdGsFiler *pFiler);
 
  virtual void insertView(int viewIndex, OdGsView* pView) = 0;
 
  virtual bool eraseView(OdGsView* pView) = 0;
  
  virtual bool eraseView(int viewIndex) = 0;
 
  virtual void eraseAllViews() = 0;
 
  virtual int numViews() const = 0;
 
  virtual OdGsView* viewAt(int viewIndex) = 0;
 
  virtual bool setBackgroundColor(ODCOLORREF backgroundColor) = 0;
 
  virtual ODCOLORREF getBackgroundColor() = 0;
 
  virtual void setLogicalPalette(const ODCOLORREF* logicalPalette, int numColors) = 0;
 
  virtual const ODCOLORREF* getLogicalPalette(int &numColors) const = 0;
 
  virtual void getSnapShot(OdGiRasterImagePtr &pImage, const OdGsDCRect &region) = 0;
 
  virtual OdGsUpdateManagerPtr getUpdateManager( bool createIfNotExist = false );
 
  virtual void setUpdateManager( OdGsUpdateManagerPtr pManager );
};
 
class OdGsModule;
 
class FIRSTDLL_EXPORT OdGsReactor : public OdRxObject
{
public:
  virtual void viewWasCreated(OdGsView* pView);
 
  virtual void viewToBeDestroyed(OdGsView* pView);
 
  virtual void viewToBeUpdated(OdGsView* pView, int flags);
 
  virtual void viewWasUpdated(OdGsView* pView, int flags);
 
  virtual void gsToBeUnloaded(OdGsModule* pModule);
};
 
class FIRSTDLL_EXPORT OdGsModule : public OdRxModule
{
public:
  ODRX_DECLARE_MEMBERS(OdGsModule);
 
  virtual OdGsDevicePtr createDevice() = 0;
 
  virtual OdGsDevicePtr createBitmapDevice();
 
  virtual void addReactor(OdGsReactor* pReactor) = 0;
 
  virtual void removeReactor(OdGsReactor* pReactor) = 0;
};
 
typedef OdSmartPtr<OdGsModule> OdGsModulePtr;
 
const OdGsMarker kNullSubentIndex = 0;
 
#include "TD_PackPop.h"
 
#endif // __GS_H_INCLUDED_