Gs.h

Go to the documentation of this file.

// Copyright (C) 2002-2017, 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-2017 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;
 
#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,
    kPerspective  = 1
  };
 
  enum SelectionMode
  {
    kWindow       = 0,
    kCrossing     = 1,
    kFence        = 2,
    kWPoly        = 3,
    kCPoly        = 4,
 
    kPoint        = 16
  };
 
  enum DefaultLightingType
  {
    kOneLight = 0,
    kTwoLights,
    kBackLight
  };
 
  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 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,
    kDeviceBackground,
    kPaletteBackground
  };
 
  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;
};
 
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 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 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_