glgeometry.h

/*
Copyright (c) 2000-2003 Lee Thomason (www.grinninglizard.com)
Grinning Lizard Utilities.

This software is provided 'as-is', without any express or implied 
warranty. In no event will the authors be held liable for any 
damages arising from the use of this software.

Permission is granted to anyone to use this software for any 
purpose, including commercial applications, and to alter it and 
redistribute it freely, subject to the following restrictions:

1. The origin of this software must not be misrepresented; you must 
not claim that you wrote the original software. If you use this 
software in a product, an acknowledgment in the product documentation 
would be appreciated but is not required.

2. Altered source versions must be plainly marked as such, and 
must not be misrepresented as being the original software.

3. This notice may not be removed or altered from any source 
distribution.
*/


#ifndef GRINLIZ_GEOMETRY_INCLUDED
#define GRINLIZ_GEOMETRY_INCLUDED

#include "glvector.h"
#include "glrectangle.h"
#include "glmatrix.h"

namespace grinliz {

template< class T>
inline T DotProduct( const Vector2<T>& v0, const Vector2<T>& v1 )
{
        return v0.x*v1.x + v0.y*v1.y;
}

template< class T>
inline void CrossProduct( const Vector3<T>& u, const Vector3<T>& v, Vector3<T>* w )
{
        GLASSERT( &u != w && &v != w );

        w->x = u.y * v.z - u.z * v.y;
        w->y = u.z * v.x - u.x * v.z;
        w->z = u.x * v.y - u.y * v.x;
}

template< class T>
inline T DotProduct( const Vector3<T>& v0, const Vector3<T>& v1 )
{
        return v0.x*v1.x + v0.y*v1.y + v0.z*v1.z;
}


struct BoundingSphere
{
        Vector3F        point;
        float           rad;

};


struct Plane
{
        static void CreatePlane( const Vector3F* vertices, Plane* plane );

        Vector3F        n;      // normal
        float           d;      // offset

        float Z( float x, float y )     { return -( d + (n.x * x) + (n.y * y) ) / ( n.z ); }

        void Normalize()
        {
                float div = 1.0f / sqrtf( ( n.x * n.x ) + ( n.y * n.y ) + ( n.z * n.z ) );
                n.x *= div;
                n.y *= div;
                n.z *= div;
                d   *= div;
        }
};


class Quaternion
{
  public:
    Quaternion()        { x = y = z = 0.0f; w = 1.0f; }

        void Normalize();

        const void ToAxisAngle( Vector3F* axis, float* angleOut );
        const void ToMatrix( Matrix4* matrix );
        void FromRotationMatrix( const Matrix4& matrix );
        void FromAxisAngle( const Vector3F& axis, float angle );

        static void SLERP( const Quaternion& start, const Quaternion& end, float t, Quaternion* result );
        static void Multiply( const Quaternion& a, const Quaternion& b, Quaternion* result );

        float x, y, z, w;
};


enum
{
        REJECT = 0,             // No intersection.
        INTERSECT,              // Intersected
        POSITIVE,               // All comparison positive
        NEGATIVE,               // All Comparison negative
        INSIDE,                 // An intersection, expected to be outside of the object, is originating inside
};

enum 
{
        // Reordering would be bad. x=0, y=1, z=2
        YZ_PLANE,
        XZ_PLANE,
        XY_PLANE
};


int ComparePlaneAABB( const Plane&, const Rectangle3F& aabb );

// Seemed interesting...but doesn't actually work to cache the plane.
//int CachePlaneAABB( const Plane& );
//int ComparePlaneAABB( const Plane&, const Rect3& aabb, int cache );

inline int IntersectPlaneAABB( const Plane& p, const Rectangle3F& aabb )
{
        return ( ComparePlaneAABB( p, aabb ) == INTERSECT ) ? INTERSECT : REJECT; 
}


int IntersectRayTri(    const Vector3F& point, const Vector3F& dir,
                                                const Vector3F& vert0, const Vector3F& vert1, const Vector3F& vert2,
                                                Vector3F* intersect );

int IntersectRayAAPlane(        const Vector3F& point, const Vector3F& dir,
                                                        int planeType, float planeLoc,
                                                        Vector3F* intersect,
                                                        float* t );
                                                 
int IntersectRayAABB(   const Vector3F& origin, const Vector3F& dir,
                                                const Rectangle3F& aabb,
                                                Vector3F* intersect,
                                                float* t );


int IntersectRayZPlane( const Vector3F& origin, const Vector3F& dir,
                                                float z,
                                                Vector3F* intersect );

};      // namespace grinliz
#endif

---