gre/3dfilter.h

Go to the documentation of this file.

/**
 * \file 3dfilter.h <gre/3dfilter.h>
 * \brief 
 *
 * \if NODOC
 * $Id: 3dfilter.h_v 1.7 2004/12/01 16:26:05 vdronov Exp $
 *
 * $Log: 3dfilter.h_v $
 * Revision 1.7  2004/12/01 16:26:05  vdronov
 *       double ALIGN8(m_MipMapBluriness);   //!< 0.50
 *
 * Revision 1.6  2004/08/11 22:59:51  vdronov
 * *** empty log message ***
 *
 * Revision 1.5  2003/09/15 13:48:59  fileserver!dwilliss
 * Doxygen
 *
 * Revision 1.4  2003/08/15 20:33:13  vdronov
 * add docs.
 *
 * Revision 1.3  2003/07/30 13:45:09  mju
 * Check inclusion guards.
 * Ignore private section.
 *
 * Revision 1.2  2003/04/10 17:51:48  vdronov
 * added MipMapSharpness
 *
 * Revision 1.1  2003/03/10 15:05:32  vdronov
 * Initial revision
 * \endif
**/ 

#ifndef  INC_GRE_3DFILTER_H
#define  INC_GRE_3DFILTER_H

#ifndef  INC_GRE_3DUTILS_H
#include <gre/3dutils.h>
#endif

#ifndef  INC_GRE_3DSCENE_H
#include <gre/3dscene.h>
#endif

#ifndef  INC_GRE_3DTEXTUR_H
#include <gre/3dtextur.h>
#endif

namespace GRE {

//! TEXTUREFILTER class provides several texture filter algorithms
class TEXTUREFILTER {
   public:

      enum MODE {
         MODE_None = 0,
         MODE_NearestNeighbor = 1,
         MODE_Bilinear = 2,
         MODE_UpperMipMapNearestNeighbor = 3,
         MODE_LowerMipMapBilinear = 4,
         MODE_MipMapTrilinear = 5,
         MODE_MipMapAnisotropic = 6
         };

      TEXTUREFILTER (                                 //! Constructor 
         ) :
         m_IsSet(false),
         m_Mode(MODE_None),
         m_AnisotropicLimit(2),
         m_MipMapSharpness(50),
         m_MipMapBluriness(0.50),
         m_Texture(0),
         m_Scene(0),
         m_ScreenPlane(0)
         {
         }

      ~TEXTUREFILTER (                                //! Destructor 
         ) {}

      //! Set scene
      void SetScene (
         SCENE3D* scene
         ) { m_Scene = scene; CheckSet(); return; }

      //! Set texture to be filtered
      void SetTexture (
         TEXTURE* texture
         ) { m_Texture = texture; CheckSet(); return; }

      //! Set screen plane
      void SetScreenPlane (
         SCREENPLANE* plane
         ) { m_ScreenPlane = plane; CheckSet(); return; }

      //! Set texture filter mode
      void SetMode (
         const MODE& mode
         ) { m_Mode = mode; CheckSet(); return; }

      //! Get texture filter mode
      //!
      //! @return current texture filter mode
      MODE GetMode (
         ) const { return m_Mode; }

      //! Get color for given screen pixel and its corresponding model point
      //!
      //! @return true if color was retrived
      bool GetColor (
         const DPOINT3D& point,
         const INT32 line,
         const INT32 column,
         COLOR& color
         );

      //! Get color for given screen pixel
      //!
      //! @return true if color was retrived
      bool GetColor (
         const INT32 line,
         const INT32 column,
         COLOR & color
         );

      //! Is texture filter set
      //!
      //! @return true if texture filter is set
      bool IsSet (
         ) { return m_IsSet; }

      //! Set anisatropic filter limit in range [2, 64]
      void SetAnisotropicLimit (
         const UINT8 limit
         ) { m_AnisotropicLimit = ((limit < 2) ? 2 : ((limit > 64) ? 64 : limit)); return; }

      //! Set mipmap sharpnes in range [0, 100]
      void SetMipMapSharpness (
         const UINT8 sharpness
         ) { 
         m_MipMapSharpness = ((sharpness > 100) ? 100 : sharpness); 
         m_MipMapBluriness = 0.01 * (100 - m_MipMapSharpness);
         return; 
         }

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT

      MODE m_Mode;
      TEXTURE* m_Texture;
      SCENE3D* m_Scene;
      SCREENPLANE* m_ScreenPlane;

      UINT8 m_AnisotropicLimit;
      UINT8 m_MipMapSharpness;         //!< 50
      double ALIGN8(m_MipMapBluriness);   //!< 0.50

      bool m_IsSet;

      void CheckSet (
         );

      bool GetDepth (
         const INT32 line,
         const INT32 column,
         UINT8& depth,
         double& fraction
         );

      bool CalculateDepth (
         const double value,
         UINT8& depth,
         double& fraction
         );

      bool GetNearestNeighborColor (
         const DPOINT2D& point,
         const UINT8 depth,
         COLOR& color 
         );

      bool GetBilinearColor (
         const DPOINT2D& point,
         const UINT8 depth,
         COLOR& color 
         );

      bool GetTrilinearColor (
         const DPOINT2D& point,
         const UINT8 depth,
         const double fraction,
         COLOR& color 
         );

      bool GetAnisotropicColor (
         const INT32 line,
         const INT32 column,
         const DPOINT2D& point,
         COLOR& color 
         );

   #endif //!< GENERATING_DOXYGEN_OUTPUT
   };

};    //! End of namespace

#endif

---