Gs.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 __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 OdGsRayTraceReactor;
 
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                                   // No render mode.
  };

  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.
    kPointLast    = 17  // Same as kPoint, but for 2D render mode it returns last selected object.
  };

  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, const OdUInt16* altSourceLwds = NULL) = 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 rayTrace(const OdGePoint3d &rayOrigin, const OdGeVector3d &rayDirection,
                        OdGsRayTraceReactor *pReactor, bool bSortedSelection = false,
                        OdGiPathNode const* const* pObjectList = NULL, OdUInt32 nObjectListSize = 0) = 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 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_