opengles拾取,碰撞检测,相交检测

本例用AABB来实现opengl中的拾取功能,AABB在opengl中可用来做相交检测，碰撞检测，本例用于检测鼠标指向的射线是否和物体相交

AABB实现类

   template<typename T>
    class   AxisAlignedBox
    {
    public:
        enum Extent
        {
            EXTENT_NULL,  //是否被初始化
            EXTENT_FINITE,//有限大
            EXTENT_INFINITE//无限大
        };
    public:
	    tvec3<T>    _minimum;//最小值
	    tvec3<T>    _maximum;//最大值
        Extent      _extent;//扩展变量
    public:
	    /*
	    1-----2
	    /|    /|
	    / |   / |
	    5-----4  |
	    |  0--|--3
	    | /   | /
	    |/    |/
	    6-----7
	    */
	    typedef enum 
        {
		    FAR_LEFT_BOTTOM     =   0,
		    FAR_LEFT_TOP        =   1,
		    FAR_RIGHT_TOP       =   2,
		    FAR_RIGHT_BOTTOM    =   3,
		    NEAR_RIGHT_BOTTOM   =   7,
		    NEAR_LEFT_BOTTOM    =   6,
		    NEAR_LEFT_TOP       =   5,
		    NEAR_RIGHT_TOP      =   4
	    } CornerEnum;

	    AxisAlignedBox()
	    {
		    _minimum    =   tvec3<T>( T(-0.5), T(-0.5), T(-0.5) );
		    _maximum    =   tvec3<T>( T(0.5), T(0.5), T(0.5) );
            _extent     =   EXTENT_NULL;
	    }
	    AxisAlignedBox(const AxisAlignedBox & rkBox)
	    {
            setExtents( rkBox._minimum, rkBox._maximum );
            _extent =   rkBox._extent;
	    }

	    AxisAlignedBox( const tvec3<T>& min, const tvec3<T>& max )
	    {
		    setExtents( min, max );
	    }

	    AxisAlignedBox(
		    T mx, T my, T mz,
		    T Mx, T My, T Mz
            )
	    {
		    setExtents( mx, my, mz, Mx, My, Mz );
	    }

	    AxisAlignedBox<T>& operator=(const AxisAlignedBox<T>& right)
	    {
            setExtents(right._minimum, right._maximum);
		    return *this;
	    }

	    ~AxisAlignedBox()
	    {
	    }
	    /** 
        *   获取最小值
	    */
	    const tvec3<T>& getMinimum(void) const
	    { 
		    return _minimum; 
	    }

	    /** 
        *   Gets a modifiable version of the minimum
	    *   corner of the box.
	    */
	    tvec3<T>& getMinimum(void)
	    { 
		    return _minimum; 
	    }

		//设置最小值
        void    setMinimum(const tvec3<T>& mins)
        { 
            _minimum    =   mins;
        }
        void    setMinimum(T x,T y, T z)
        { 
            _minimum    =   tvec3<T>(x,y,z);
        }
	    /** 
        *   Gets the maximum corner of the box.
	    */
	    const tvec3<T>& getMaximum(void) const
	    { 
		    return _maximum;
	    }
	    /** 
        *   Gets a modifiable version of the maximum
	    *   corner of the box.
	    */
	    tvec3<T>& getMaximum(void)
	    { 
		    return _maximum;
	    }
	    /** 
        *   Sets the maximum corner of the box.
	    */
	    void setMaximum( const tvec3<T>& vec )
	    {
		    _maximum = vec;
	    }

	    void setMaximum( T x, T y, T z )
	    {
		    _maximum.x = x;
		    _maximum.y = y;
		    _maximum.z = z;
	    }

	    /** 
        *   Changes one of the components of the maximum corner of the box
	    *   used to resize only one dimension of the box
	    */
	    void setMaximumX( T x )
	    {
		    _maximum.x = x;
	    }

	    void setMaximumY( T y )
	    {
		    _maximum.y = y;
	    }

	    void setMaximumZ( T z )
	    {
		    _maximum.z = z;
	    }

	    /** 
        *   设置包围盒的大小  min:最小值   max:最大值
	    */
	    void setExtents( const tvec3<T>& min, const tvec3<T>& max )
	    {
		    _minimum    =   min;
		    _maximum    =   max;
            _extent     =   EXTENT_FINITE;
	    }
		//设置包围盒大小  mx my mz 最小值xyz  Mx My  Mz 最大值xyz
	    void setExtents(
		    T mx, T my, T mz,
		    T Mx, T My, T Mz )
	    {
		    _minimum.x  =   mx;
		    _minimum.y  =   my;
		    _minimum.z  =   mz;

		    _maximum.x  =   Mx;
		    _maximum.y  =   My;
		    _maximum.z  =   Mz;
            _extent     =   E