source: orxonox.OLD/branches/terrain.old/src/lib/graphics/importer/terrain/frustum.h @ 10615

/*
        orxonox - the future of 3D-vertical-scrollers

        Copyright (C) 2006 orx

        This program is free software; you can redistribute it and/or modify
        it under the terms of the GNU General Public License as published by
        the Free Software Foundation; either version 2, or (at your option)
        any later version.

        ### File Specific:
        main programmer: Marco Biasini

 */
#ifndef _FRUSTUM_H
#define _FRUSTUM_H
#include "plane.h"
#include "vector.h"
#include "types.h"
#include "glincl.h"
#include <stdio.h>


#define MAX_CLIP_DISTANCE 800.0f
#define m( _col, _row )  _m[_row*4+_col]

#define CHECK_GL_ERROR( _d ) do { \
        GLenum __err = glGetError(); \
        if ( __err != GL_NO_ERROR ) \
                printf( "check%s: %s\n", _d, (char*)gluErrorString( __err ) );\
        }\
        while ( 0 )

/**
 * Code borrowed from Lighthouse 3D. Its a very good tutorial on culling.
 */
class Frustum;
typedef Frustum *pFrustum;
class Frustum {

        public:

                enum { NEAR = 0 , FAR = 1, TOP = 2, BOTTOM = 3, LEFT = 4, RIGHT = 5 };
                enum { OUTSIDE, INTERSECT, INSIDE };

                Frustum()
                {
                        planes = new Plane[6];
                }
                ~Frustum()
                {
                        if ( planes )
                                delete[] planes;
                }
                /**
                 * Extracts the frustum planes from the GL_PROJECTION and GL_MODELVIEW
                 * matrices...
                 */
                inline void extractPlanes()
                {
                        float proj[16], view[16], combined[16];
                        glGetFloatv( GL_MODELVIEW_MATRIX, view );
                        glGetFloatv( GL_PROJECTION_MATRIX, proj );
                        multMat( combined, view, proj );
                        setFrustum( combined );
                }

                inline int boxInFrustum( const ABox& _box )
                {
                        int result = INSIDE;
                        //for each plane do ...
                        for( int i = 0; i < 6; ++i ) {

                                // is the positive vertex outside?
                                if ( planes[i].distancePoint( _box.vertexP( planes[i].n ) ) < 0 )
                                        return OUTSIDE;
                                // is the negative vertex outside?
                                else if ( planes[i].distancePoint( _box.vertexN( planes[i].n ) ) < 0 )
                                        result = INTERSECT;
                        }
                        return result;
                }

                inline int pointInFrustum( const Vector& _point)
                {
                        int result = INSIDE;
                        for(int i=0; i < 6; i++) {
                                if (planes[i].distancePoint( _point ) < 0)
                                        return OUTSIDE;
                        }
                        return result;
                }

                inline Plane getPlane( int _plane ) { return planes[_plane]; }

                inline void setFrustum( float *_m )
                {
                        planes[NEAR] =  Plane( Vector(
                                m(2,0) + m(3,0),
                                m(2,1) + m(3,1),
                                m(2,2) + m(3,2) ),
                                m(2,3) + m(3,3) );

                        planes[FAR] = Plane( Vector(
                                -m(2,0) + m(3,0),
                                -m(2,1) + m(3,1),
                                -m(2,2) + m(3,2) ),
                                -m(2,3) + m(3,3) );

                        planes[BOTTOM] = Plane( Vector(
                                m(1,0) + m(3,0),
                                m(1,1) + m(3,1),
                                m(1,2) + m(3,2) ),
                                m(1,3) + m(3,3) );
                        planes[TOP] = Plane( Vector(
                                -m(1,0) + m(3,0),
                                -m(1,1) + m(3,1),
                                -m(1,2) + m(3,2) ),
                                -m(1,3) + m(3,3) );
                        planes[LEFT] = Plane( Vector(
                                m(0,0) + m(3,0),
                                m(0,1) + m(3,1),
                                m(0,2) + m(3,2) ),
                                m(0,3) + m(3,3) );
                        planes[RIGHT] =  Plane( Vector(
                                -m(0,0) + m(3,0),
                                -m(0,1) + m(3,1),
                                -m(0,2) + m(3,2) ),
                                -m(0,3) + m(3,3) );

                        if ( planes[NEAR].k +planes[FAR].k  > MAX_CLIP_DISTANCE ) {
                                planes[FAR].k = -planes[NEAR].k+MAX_CLIP_DISTANCE;
                        }
                }

        protected:
                Plane           *planes;
};

#endif