gre/layerview.h

Go to the documentation of this file.

#ifndef  INC_GRE_LAYERVIEW_H
#define  INC_GRE_LAYERVIEW_H

#ifndef  INC_GRE_BASE_H
   #include <gre/base.h>
#endif

#ifndef  INC_GRE_LABELPLACEMENT_H
   #include <gre/labelplacement.h>
#endif

#ifndef  INC_MI32_RENDERBUFFER_H
   #include <mi32/renderbuffer.h>
#endif

#ifndef  INC_MI32_TRANS2DC_H
   #include <mi32/trans2dc.h>
#endif

#ifndef  INC_MI32_CRITSEC_H
   #include <mi32/critsec.h>
#endif


class UNSIGNEDSET;
namespace MITHREAD {
   class QUEUE;
   }


namespace GRE {

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

class LAYERVIEW {
   public:

      LAYERVIEW (
         GRE::LAYER *layer,
         GRE::VIEW *view
         );

      LAYERVIEW (
         GRE::LAYER *layer,
         GRE::VIEW *view,
         const TRANS2D_MAPGEN& TransObjectToDevice,
         INT32 DevSizeX,
         INT32 DevSizeY
         );

      virtual ~LAYERVIEW ();

      void AttachSection (
         GRE::LAYERSECTION *& pLayerSection,    
         bool NotifyView = true
         );

      void CheckRendered ();

      void ClearLabelPlacement ();

      ERRVALUE ComputeTrans ();

      bool DetachSection (
         const LAYERSECTION *pLayerSection   
         );

      ERRVALUE DrawElementToBuffer (
         ELEMTYPE ElemType,
         ELEMNUM ElemNum,
         GRE::RENDERTARGET content,
         GRE::DRAWFLAGS drawflags
         );

      ERRVALUE DrawElementToDevice (
         ELEMTYPE ElemType,
         ELEMNUM ElemNum,
         MGD::DEVICE *pDevice,
         GRE::DRAWFLAGS drawflags
         );

      ERRVALUE DrawElementsToBuffer (
         ELEMTYPE ElemType,
         const UNSIGNEDSET *pElemSet,
         GRE::RENDERTARGET content,
         GRE::DRAWFLAGS drawflags
         );

      ERRVALUE DrawElementsToDevice (
         ELEMTYPE ElemType,
         const UNSIGNEDSET *pElemSet,
         MGD::DEVICE *pDevice,
         GRE::DRAWFLAGS drawflags
         );

      ERRVALUE DrawHighlightedToBuffer (
         GRE::DRAWFLAGS drawflags
         );

      double Get3dDepthScale (
         ) const { return (m_3dDepthScale); }

      double Get3dSurfaceIncrement (
         ) const { return (m_3dSurfaceIncrement); }

      const GRE::VIEWPOINT3D* Get3dViewPoint (
         ) const { return (m_pViewPoint3D); }

      double Get3dZScale (
         ) const { return (m_3dZScale); }

      double GetDesignScale (
         ) const { return (m_DesignScale); }

      const LRECT2D& GetDeviceRectUsed (
         ) const { return (m_CurDevRectUsed); }

      const UNSIGNEDSET* GetElemDrawnSet (
         ELEMTYPE ElemType,                              
         bool UseHighlighted                             
         ) const;

      UNSIGNEDSET* GetElemDrawnSet (
         ELEMTYPE ElemType,                              
         bool UseHighlighted                             
         );

      LABELPLACEMENT* GetLabelPlacement (
         bool ReturnNullIfEmpty = true                   
         );

      GRE::LAYER* GetLayer (
         ) const { return (m_layer); }

      const LAYERSECTION* GetSection (
         ) const { return (m_pSectionUntiled); }

      LAYERSECTION* GetSection (
         ) { return (m_pSectionUntiled); }

      GRE::LAYER_SURFACE* GetSurfaceLayer (
         ) const { return (m_pSurfaceLayer); }

      const TRANS2D_MAPGEN& GetTransLayerDevice (
         ) const { return (m_TransLayerDevice); }

      const TRANS2D_MAPGEN& GetTransLayerSurface (
         ) const { return (m_TransLayerSurface); }

      const TRANS2D_MAPGEN& GetTransLayerView (
         ) const { return (m_TransLayerView); }

      GRE::VIEW* GetView () const
         { return (m_view); }

      bool HasRendered (
         RENDERTARGET content = RENDERTARGET_LayerAll
         ) const;

      bool Is3D () const
         { return (m_Is3D); }

      bool Is3dStereo () const;

      bool IsAttachedToView () const;

      bool IsSurfaceUsed (
         ) const { return (m_IsSurfaceUsed); }

      bool IsLayerOverlappedDevice (
         ) const { return (m_LayerOverlapsDevice); }

      bool OverlayBufferIfRendered (
         GRE::RENDERTARGET content,                      
         MGD::DEVICE *pDevTarget,                        
         const LRECT2D *pClipRect = 0                    
         ) const;

      ERRVALUE QueueJobRenderFull (
         MITHREAD::QUEUE& Queue                          
         );

      void ResetAllDrawnSets ();

      void ResetRendered (
         GRE::RENDERTARGET target = GRE::RENDERTARGET_LayerAll
         );

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      GRE::LAYER *m_layer;
      GRE::VIEW *m_view;
      LAYERSECTION *m_pSectionUntiled;
      TRANS2D_MAPGEN m_TransLayerView;
      TRANS2D_MAPGEN m_TransLayerDevice;
      TRANS2D_MAPGEN m_TransLayerSurface;
      GRE::VIEWPOINT3D *m_pViewPoint3D;         // 3D viewpoint
      GRE::LAYER_SURFACE *m_pSurfaceLayer;      // Surface layer in 3D
      DRECT2D m_NewTgtRectFull;                 // New full rectangle in target device coordinates, based on transformation
      DRECT2D m_CurTgtRectFull;                 // Current full rectangle in target device coordinates used by layer
      DRECT2D m_PrevObjRectFull;                // Previous full object rectangle (for detecting extent changed)
      LRECT2D m_NewDevRectUsed;                 // New clipped rectangle on device used, based on transformation
      LRECT2D m_CurDevRectUsed;                 // Current clipped rectangle on device used
      double m_DesignScale;                     // Design scale of layout/group for relative size
      double m_3dSurfaceIncrement;              // Increment in layer corresponding to one cell in surface raster
      double m_3dDepthScale;                    // Map scale factor for 3D (multiply by depth to get actual scale)
      double m_3dZScale;
      bool m_Is3D;                              // Set if drawing in 3D
      bool m_IsSurfaceUsed;                     // Use surface layer for Z value
      bool m_LayerOverlapsDevice;
      bool m_TransChanged;
      mutable MITHREAD::CRITICALSECTION m_CritSec;

      LAYERVIEW (const LAYERVIEW&);
      LAYERVIEW& operator= (const LAYERVIEW&);

      #endif // GENERATING_DOXYGEN_OUTPUT

   };

//===================================================================================================================
}  // End namespace GRE

#endif   // INC_GRE_LAYERVIEW_H

---