layerdc.h

Go to the documentation of this file.

/**
 * \file layerdc.h <gre/layerdc.h>
 * \brief GRE_LAYERDC class definition
 *
 * \if NODOC
 * $Id: layerdc.h_v 1.31 2005/05/03 15:02:25 mju Exp $
 *
 * $Log: layerdc.h_v $
 * Revision 1.31  2005/05/03 15:02:25  mju
 * Keep track of render target.
 * Add checkColorLock using elemtype/num and highlightset.
 *
 * Revision 1.30  2005/05/02 20:40:08  mju
 * Add checkColorOverride.
 *
 * Revision 1.29  2005/05/02 17:44:06  mju
 * Add checkColorLock.
 *
 * Revision 1.28  2005/03/01 14:21:15  mju
 * Add methods to access drawn sets.
 *
 * Revision 1.27  2005/02/25 20:31:31  mju
 * Include groupview hdr.
 *
 * Revision 1.26  2005/02/25 18:54:37  mju
 * Include layerview hdr.
 *
 * Revision 1.25  2005/02/25 17:47:27  mju
 * Remove setup2D/3D, add CanDrawLayer, Set3dStereoView.
 *
 * Revision 1.24  2005/02/24 20:38:57  mju
 * Remove commented-out method.
 *
 * Revision 1.23  2005/02/24 18:52:39  mju
 * Remove getBackgroundColor.
 * Make setDrawFlags non-inline.
 *
 * Revision 1.22  2005/02/23 18:53:08  mju
 * Add non-const getLayerView method.
 *
 * Revision 1.21  2005/02/23 16:56:08  mju
 * Add non-const variant of getLayerView.
 *
 * Revision 1.20  2005/02/14 18:53:11  mju
 * Use groupview.
 *
 * Revision 1.19  2005/02/04 18:57:35  mju
 * Add ctors using mgd device.
 * Add setDrawingDevice.
 * Deprecate ctors using mgd context.
 *
 * Revision 1.18  2005/01/27 21:42:47  mju
 * Undeprecate ctor.
 *
 * Revision 1.17  2005/01/24 21:37:24  mju
 * Add non-const get3dScene.
 *
 * Revision 1.16  2005/01/24 21:31:36  mju
 * Move members which can be saved between drawing to layerview.
 *
 * Revision 1.14  2005/01/21 17:30:29  mju
 * Make all members private.
 *
 * Revision 1.13  2005/01/20 22:47:31  mju
 * Add accessor methods.
 *
 * Revision 1.12  2005/01/20 16:55:43  mju
 * Enums for drawmode.
 *
 * Revision 1.11  2004/03/12 16:07:19  mju
 * Add isHidden fn.
 *
 * Revision 1.10  2004/03/05 17:01:57  mju
 * Make dtor virtual since has virtual fns.
 *
 * Revision 1.9  2003/10/06 20:47:23  mju
 * Add NotifyDrawElementBegin/End.
 *
 * Revision 1.8  2003/09/15 13:48:59  fileserver!dwilliss
 * Doxygen
 *
 * Revision 1.7  2003/09/10 17:03:44  scowan
 * Create no trans draw line clipped function.
 *
 * Revision 1.6  2003/07/31 22:09:43  mju
 * Ignore private section.
 *
 * Revision 1.5  2003/06/14 02:11:02  scowan
 * Removed dregion and changed to region2d.
 *
 * Revision 1.4  2003/06/04 23:13:54  scowan
 * Added methods and removed simple array.
 *
 * Revision 1.3  2003/03/20 23:14:49  vdronov
 * new trans
 *
 * Revision 1.2  2003/03/05 20:41:32  mju
 * Add GetTransLayerToDevice
 *
 * Revision 1.1  2002/09/19 17:08:41  mju
 * Initial revision
 *
 * \endif
**/

#ifndef  INC_GRE_LAYERDC_H
#define  INC_GRE_LAYERDC_H

#ifndef  INC_GRE_VIEW_H
   #include <gre/view.h>
#endif

#ifndef  INC_GRE_GROUP_H
   #include <gre/group.h>
#endif

#ifndef  INC_GRE_LAYERVIEW_H
   #include <gre/layerview.h>
#endif

#ifndef  INC_GRE_GROUPVIEW_H
   #include <gre/groupview.h>
#endif

#ifndef  INC_GRE_LRSURFACE_H
   #include <gre/lrsurface.h>
#endif

#ifndef  INC_MI32_REGION2D_H
   #include <mi32/region2d.h>
#endif

#ifndef  INC_MI32_SML_H
   #include <mi32/sml.h>
#endif


//===================================================================================================================
//! Layer drawing context.
//! Contains information needed to actually draw layer on a particular view.
class GRE_LAYERDC : public POLYLINE::CLIP {
   public:

      //! Construct using layer, view and drawing device.
      GRE_LAYERDC (
         GRE_LAYER *layer,                   //!< Layer, must not be NULL
         GRE_VIEW *view,                     //!< View, should not be NULL
         MGD::DEVICE* pDevice = 0,
         GRE::DRAWFLAGS drawflags = GRE::DRAWFLAG_None
         );

      //! Construct using view, drawing device and transformation.
      //! Does not need a layer, but you need to calculate the transformation and pass it in.
      GRE_LAYERDC (
         GRE_VIEW *view,                     //!< View, cannot be NULL
         MGD::DEVICE* pDevice,               //!< Drawing device, cannot be NULL
         const TRANS2D_MAPGEN& ObjectToDevice,
         GRE::DRAWFLAGS drawflags = GRE::DRAWFLAG_None
         );

      //! Destructor.
      virtual ~GRE_LAYERDC ();

      //! Determine if possible to draw layer.
      //! @return false if out of view or cannot draw based on 2D/3D view type.
      bool CanDrawLayer (
         ) const;

      //! Check if drawing flags require a color lock, set color and lock if so.
      bool CheckColorLock (
         MGD::COLORLOCK& colorlock           //!< Color lock passed/returned
         );

      //! Check if drawing flags require a color lock, set color and lock if so.
      bool CheckColorLock (
         MGD::COLORLOCK& colorlock,          //!< Color lock passed/returned
         ELEMTYPE ElemType,                  //!< Element type
         INT32 ElemNum,                      //!< Element number
         const BITSET& HighlightSet          //!< Highlight set
         );

      //! Check if drawing flags require a color override.
      bool CheckColorOverride (
         COLOR& color                        //!< Override color returned
         );

      void ClearAllDrawnSets (
         );

      //! Draw line in 2D, does not translate or clip
      //! @return TRUE if visible, FALSE if not, < 0 if error.
      ERRVALUE DrawLine2D (
         POLYLINE& PolyLine
         ) { return (OnClip(PolyLine)); }

      //! Translate, clip and draw line in 2D
      //! @return TRUE if visible, FALSE if not, < 0 if error.
      int DrawLineClipped2D (
         POLYLINE& PolyLine
         ) const;

      //! Clip and draw line in 2D
      //! @return TRUE if visible, FALSE if not, < 0 if error.
      int DrawLineClipped2DNoTrans (
         POLYLINE& PolyLine
         ) const;

      //! Translate, clip and draw line in 3D
      //! @return TRUE if visible, FALSE if not, < 0 if error.
      int DrawLineClipped3D (
         POLYLINE& PolyLine
         ) const;

      //! Translate, clip and draw line in 3D
      //! @return TRUE if visible, FALSE if not, < 0 if error.
      int DrawLineClipped3D (
         DPOINT3D* points,                   //!< Array of points with X/Y coordinates in layer associated with context
         INT32 NumPoints                     //!< Number of points
         ) const;

      //! Clip and draw segment in 3D.
      //! @return TRUE if visible, FALSE if not, < 0 if error.
      int DrawSegment3D (
         const DPOINT3D& point1,             //!< First point in map coordinates
         const DPOINT3D& point2              //!< Second point in map coordinates
         ) const;

      //! Fill 3D flat polygon.
      //! @return true if was visible, false if not.
      bool Fill3dFlatPolygon (
         const DPOINT3D *points,             //!< Polygon vertices
         INT32 numPoints                     //!< Number of vertices
         ) const;

      //! Fill 3D triangle.
      //! @return true if was visible, false if not.
      bool Fill3dTriangle (
         const DPOINT3D *tp[3]               //!< Pointers to triangle vertices
         ) const;

      //! Get depth scaling, multiplied by depth to get drawing scale.
      double Get3dDepthScale (
         ) const { return (m_pLayerView->Get3dDepthScale()); }

      //! Get 3D scene containing 3D transformations.
      const GRE::SCENE3D& Get3dScene (
         ) const { return (m_Scene3D); }

      //! Get 3D scene containing 3D transformations.
      GRE::SCENE3D& Get3dScene (
         ) { return (m_Scene3D); }

      //! Get increment in layer relative to once cell in surface layer.
      double Get3dSurfaceIncrement (
         ) const { return (m_pLayerView->Get3dSurfaceIncrement()); }

      //! Get 3D stereo view setting.
      GRE::SCENE3D::STEREOVIEW Get3dStereoView (
         ) const { return (m_Scene3D.GetStereoView()); }

      //! Get 3D Z scaling.
      double Get3dZScale (
         ) const { return (m_pLayerView->Get3dZScale()); }

      //! Get clipping region in device coordinates.
      const REGION2D& GetClipRegion (
         ) const { return (m_ClipRegion); }

      //! Get design scale.
      double GetDesignScale (
         ) const { return (m_DesignScale); }

      //! Get drawing flags.
      GRE::DRAWFLAGS GetDrawFlags (
         ) const { return (m_drawflags); }

      //! Get drawing device context.
      MGD::CONTEXT* GetDrawingContext (
         ) const { return (m_ggc); }

      //! Get drawing device.
      MGD::DEVICE* GetDrawingDevice (
         ) const { return (m_ggc == 0 ? 0 : &m_ggc->GetDevice()); }

      //! Get scale at which layer is currently being drawn.
      double GetDrawingScale (
         ) const { return (m_DrawingScale); }

      //! Get target based on current drawing device.
      GRE::RENDERTARGET GetRenderTarget (
         ) const { return (m_RenderTarget); }

      //! Get pointer to 'drawn set' based on specified element type and current target device.
      //! @return Pointer to BITSET, NULL if none available.
      BITSET* GetElemDrawnSet (
         ELEMTYPE ElemType = ELEMTYPE_All
         ) const;

      //! Get layer.
      GRE_LAYER* GetLayer (
         ) const { return (m_layer); }

      //! Get LAYERVIEW (const).
      const GRE::LAYERVIEW* GetLayerView (
         ) const { return (m_pLayerView); }

      //! Get LAYERVIEW (non-const).
      GRE::LAYERVIEW* GetLayerView (
         ) { return (m_pLayerView); }

      bool GetNoDrawActive (
         ) const { return (m_NoDrawActive); }

      //! Get the clip rectangle in object coordinates
      const DRECT2D& GetObjectClipRect (
         ) const { return (m_ObjClipRect); }

      //! Get pixel size in millimeters.
      const DPOINT2D& GetPixelSizeMM (
         ) const { return (m_PixelSizeMM); }

      //! Get rotation angle.
      double GetRotationAngle (
         ) const { return (m_RotationAngle); }

      //! Get rotation cosine.
      double GetRotationCos (
         ) const { return (m_pGroupView->GetRotationCos()); }

      //! Get rotation sine.
      double GetRotationSin (
         ) const { return (m_pGroupView->GetRotationSin()); }

      //! Get surface layer for 3D draping.
      GRE_LAYER_SURFACE* GetSurfaceLayer (
         ) const { return (m_pLayerView->GetSurfaceLayer()); }

      //! Get surface Z coordinates for array of points.
      ERRVALUE GetSurfaceZ (
         DPOINT3D* points,                   //!< Array of points with X/Y coordinates in layer associated with context
         INT32 NumPoints                     //!< Number of points
         ) const;

      //! Get surface Z coordinates for POLYLINE.
      ERRVALUE GetSurfaceZ (
         POLYLINE& polyline                  //!< 3D polyline
         ) const;

      //! Get transformation from 'layer' to 'device' coordinates.
      const TRANS2D_MAPGEN& GetTransLayerDevice (
         ) const { return (m_pLayerView->GetTransLayerDevice()); }

      //! Get transformation from 'layer' to 'surface' coordinates.
      const TRANS2D_MAPGEN& GetTransLayerSurface (
         ) const { return (m_pLayerView->GetTransLayerSurface()); }

      GRE_VIEW* GetView (
         ) const { return (m_view); }

      //! Determine if has surface layer.
      bool HasSurfaceLayer (
         ) const { return (m_pLayerView->GetSurfaceLayer() != 0); }

      //! Determine if surface has nulls.
      bool HasSurfaceNulls (
         ) const { return (m_pLayerView->HasSurfaceNulls()); }

      //! Determine if drawing in 2D or 3D.
      bool Is3D (
         ) const { return (m_pLayerView->Is3D()); }

      //! Determine if layer is 'hidden' due to scale or other visibility setting.
      bool IsHidden (
         ) const { return (m_IsHidden); }

      //! Determine if surface (layer or flat) is being used.
      bool IsSurfaceUsed (
         ) const { return (m_pLayerView->IsSurfaceUsed()); }

      //! Send notification before drawing element.
      void NotifyDrawElementBegin (
         const RVC::ELEMENT& element
         ) const { m_view->NotifyDrawElementBegin(m_layer,element); }

      //! Send notification before drawing element.
      void NotifyDrawElementBegin (
         ELEMTYPE ElemType,
         INT32 ElemNum
         ) const { m_view->NotifyDrawElementBegin(m_layer,RVC::ELEMENT(ElemNum,ElemType)); }

      //! Send notification after drawing element.
      void NotifyDrawElementEnd (
         const RVC::ELEMENT& element
         ) const { m_view->NotifyDrawElementEnd(m_layer,element); }

      //! Send notification after drawing element.
      void NotifyDrawElementEnd (
         ELEMTYPE ElemType,
         INT32 ElemNum
         ) const { m_view->NotifyDrawElementEnd(m_layer,RVC::ELEMENT(ElemNum,ElemType)); }

      //! Set whether current element is scaled when rendered in 3D.
      void Set3dElemScaled (
         bool IsScaled
         ) { m_ScaleToMap3D = IsScaled; }

      void Set3dStereoView (
         GRE::SCENE3D::STEREOVIEW StereoView
         );

      //! Set drawing flags.
      void SetDrawFlags (
         GRE::DRAWFLAGS drawflags
         );

      //! Set drawing device.
      void SetDrawingDevice (
         MGD::DEVICE *pDevice
         );

      //! Translate 3D point to display coordinates.
      //! @return TRUE if point visible, FALSE if not, < 0 if error.
      int TransPoint3D (
         DPOINT3D& ipoint,                   //!< Point in layer coordinates, Z value may be altered if surface reference used
         DPOINT3D& opoint                    //!< Point in display coordinates with canonical depth returned
         ) const;

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT

      static SMLAUTOCLASS_NOALLOC_T<GRE_LAYERDC> s_SML_AutoClass;

      static void SML_Register ();

      GRE::GROUPVIEW *m_pGroupView;
      GRE::LAYERVIEW *m_pLayerView;
      GRE_LAYER *m_layer;
      GRE_VIEW *m_view;
      MGD::CONTEXT* m_ggc;                      // Generic graphic context
      GRE::DRAWFLAGS m_drawflags;               // Drawing flags
      REGION2D m_ClipRegion;                    // Current clipping region in device coordinates
      DRECT2D m_ObjClipRect;                    // Clipping rectangle in object coordinates
      DPOINT2D m_PixelSizeMM;                   // Device pixel size in millimeters
      double m_DesignScale;                     // Mirrored from LAYERVIEW for SML access
      double m_DrawingScale;
      double m_RotationAngle;                   // Mirrored from GROUPVIEW for SML access
      bool m_OwnGroupView;
      bool m_OwnLayerView;
      bool m_IsHidden;
      bool m_NoDrawActive;                      // Don't draw "active" element
      bool m_ScaleToMap3D;                      // Set if 3D scaling to map
      GRE::SCENE3D m_Scene3D;
      GRE::RENDERTARGET m_RenderTarget;

      void SetupForDrawFlags ();
      void SetupForStereoView ();

      // Not implemented.
      GRE_LAYERDC (const GRE_LAYERDC&);
      GRE_LAYERDC& operator= (const GRE_LAYERDC&);
      
      virtual ERRVALUE OnClip (const POLYLINE& PolyLine);

      #endif // GENERATING_DOXYGEN_OUTPUT
   };

//===================================================================================================================

#endif   // INC_GRE_LAYERDC_H

---