gre/groupview.h

Go to the documentation of this file.

#ifndef  INC_GRE_GROUPVIEW_H
#define  INC_GRE_GROUPVIEW_H

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

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

#ifndef  INC_MI32_ZVIEW_H
   #include <mi32/zview.h>
#endif


namespace GRE {

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

class GROUPVIEW {
   public:

      enum RENDERTYPE {
         RENDERTYPE_Group =      0,
         RENDERTYPE_ActiveElems,
         RENDERTYPE_Matte,
         RENDERTYPE_COUNT
         };

      GROUPVIEW (
         GRE::GROUP *group,
         GRE::VIEW *view
         );

      ~GROUPVIEW ();

      void CheckRendered ();

      ERRVALUE ComputeStereoValues ();

      ERRVALUE ComputeTrans ();

      ERRVALUE DrawActiveOverlay ();

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

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

      GRE::GROUP* GetGroup (
         ) const { return (m_group); }

      const RENDERBUFFER& GetRenderBuffer (
         RENDERTYPE RenderType                           
         ) const { return (m_RenderBuffer[RenderType]); }

      RENDERBUFFER& GetRenderBuffer (
         RENDERTYPE RenderType                           
         ) { return (m_RenderBuffer[RenderType]); }

      double GetRotationAngle (
         ) const { return (m_RotationAngle); }

      double GetRotationCos (
         ) const { return (m_RotationCos); }

      double GetRotationSin (
         ) const { return (m_RotationSin); }

      bool GetStereoInterlaceStartRight (
         ) const { return (m_StereoInterlaceStartRight); }

      const STEREOSHIFT& GetStereoShift () const
         { return (m_ZView.GetStereoShift()); }

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

      const ZVIEW& GetZView () const
         { return (m_ZView); }

      void InvalidateStereo2D (
         ) { m_ZView.InvalidateStereoShift(); }

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

      bool IsGroupOverlappedDevice (
         ) const { return (m_GroupOverlapsDevice); }

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

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      GRE::GROUP *m_group;
      GRE::VIEW *m_view;
      RENDERBUFFER m_RenderBuffer[RENDERTYPE_COUNT];
      GRE::VIEWPOINT3D *m_pViewPoint3D;            // 3D viewpoint
      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
      LRECT2D m_NewDevRectUsed;                 // New clipped rectangle on device used, based on transformation
      LRECT2D m_CurDevRectUsed;                 // Current clipped rectangle on device used
      double m_RotationAngle;                   // Rotation angle
      double m_RotationCos;                     // Rotation angle cosine
      double m_RotationSin;                     // Rotation angle sine
      ZVIEW m_ZView;
      bool m_Is3D;                              // Set if drawing in 3D
      bool m_GroupOverlapsDevice;
      bool m_StereoInterlaceStartRight;         // Set if first row/column of device is for right eye of interlaced stereo rendering

      GROUPVIEW (const GROUPVIEW&);
      GROUPVIEW& operator= (const GROUPVIEW&);

      #endif // GENERATING_DOXYGEN_OUTPUT
   };

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

}  // End namespace GRE

#endif   // INC_GRE_GROUPVIEW_H

---