gre/3dfilter.h

Go to the documentation of this file.

#ifndef  INC_GRE_3DFILTER_H
#define  INC_GRE_3DFILTER_H

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

namespace GRE {

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 (                                 
         ) :
         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 (                                
         ) {}

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

      void SetTexture (
         TEXTURE* texture
         ) { m_Texture = texture; CheckSet(); return; }

      void SetScreenPlane (
         SCREENPLANE* plane
         ) { m_ScreenPlane = plane; CheckSet(); return; }

      void SetMode (
         const MODE& mode
         ) { m_Mode = mode; CheckSet(); return; }

      MODE GetMode (
         ) const { return m_Mode; }

      bool GetColor (
         const DPOINT3D& point,
         const INT32 line,
         const INT32 column,
         COLOR& color
         );

      bool GetColor (
         const INT32 line,
         const INT32 column,
         COLOR & color
         );

      bool IsSet (
         ) { return m_IsSet; }

      void SetAnisotropicLimit (
         const UINT8 limit
         ) { m_AnisotropicLimit = ((limit < 2) ? 2 : ((limit > 64) ? 64 : limit)); return; }

      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;         
      double ALIGN8(m_MipMapBluriness);   

      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 
   };

};    

#endif

---