C:/development/RenderTools/src/factory/Camera.cpp

Go to the documentation of this file.

/* 
        Camera.cpp

        Author:                 jvanderspek
        Description:    <describe the Camera class here>
*/

#include "Camera.h"
#include "Error.h"
#include "Property.h"
#include "StateSet.h"
#include "Program.h"

namespace RenderTools {

using namespace Matrix;

CameraPtr Camera::s_current = CameraPtr();

CameraPtr Camera::getCurrent( void ){
        return( s_current );
}

Camera::Camera( void ):
        TransformNode(),
        m_type( PERSPECTIVE ),
        m_aspect( 1.0f ),
        m_mode( NONE ),
        m_modePushed( NONE ),
        m_flip( false ),
        m_flop( false ){

}

PropertyPtr Camera::create( const XMLNodePtr & xml ){
        CameraPtr p( new Camera() );
        p->setName( xml );
        p->createProperties();
        p->setProperties( xml, false );
        return( dynamic_pointer_cast< AbstractProperty, Camera >( p ) );
}

void Camera::createProperties( void ){
        createProperty( this, "type", CamTypeStruct( & m_type ), getCamTypeEnums() );
        createProperty( this, "screenSize", & m_screen );
        createProperty( this, "eye", & m_eye );
        createProperty( this, "focus", & m_center );
        createProperty( this, "zoom", & m_zoom );
        createProperty( this, "nearClip", & m_nearc );
        createProperty( this, "farClip", & m_farc );
        createProperty( this, "fieldOfView", & m_fovy );
        createProperty( this, "roll", & m_roll );
        createProperty( this, "viewport", & m_vp );
        createProperty( this, "horizontalFlip", BooleanStruct( & m_flip ) );
        createProperty( this, "verticalFlip", BooleanStruct( & m_flop ) );
        createProperty( this, "ortho", & m_ortho );
}

const string Camera::getTypeName( bool ofComponent ) const {
        return( "Camera" );
}

Camera::~Camera( void ){
        CameraPtr thisPtr = getNullDeletingSharedPtr< Camera >();
        if( s_current == thisPtr ){
                s_current = CameraPtr();
        }
}

Camera & Camera::operator = ( const Camera & c ){
        m_eye = c.m_eye;
        m_center = c.m_center;
        m_zoom = c.m_zoom;
        m_nearc = c.m_nearc;
        m_farc = c.m_farc;
        m_fovy = c.m_fovy;
        m_roll = c.m_roll;
        return( * this );
}

Camera & Camera::operator += ( const Camera & cc ){
        Camera & c = ( Camera & )cc;
        m_eye += c.m_eye;
        m_center += c.m_center;
        m_zoom += c.m_zoom;
        m_nearc += c.m_nearc;
        m_farc += c.m_farc;
        m_fovy += c.m_fovy;
        m_roll += c.m_roll;
        return( * this );
}

Camera & Camera::operator *= ( const float f ){
        m_eye *= f;
        m_center *= f;
        m_zoom *= f;
        m_nearc *= f;
        m_farc *= f;
        m_fovy *= f;
        m_roll *= f;
        return( * this );
}

void Camera::frame( const NAABB & b, float scale, bool send ){ 

        Vec3 sub,los;

        // get the center of the naabb
        Vec3 c = b.getCenter();

        // get the size of the aabb as half the diagonal
        float s = length( ( b.getHigh() - b.getLow() ) *= 0.5 );
        // scaled by the zoomfactor
        s *= m_zoom;

        // get the vector from the eye to the focuspoint
        los = m_eye - m_center;
        los = normalize( los );
        // set the eye and focuspoint to the center of the naabb
        m_center = c;
        m_eye = c;

        // get the tangent of the viewing angle
        float t = tan( ( m_fovy / 180.0 ) );
        float d = 0.0;

        // d will be the distance to the naabb 
        // so that it fits in the frustum
        if( t != 0.0 ){
                d = ( s / t );
        }
        // but dont exaggerate
        if( d > 1000.0f )d = 1000.0f;
        // move the eye away from the focuspoint,
        // keeping the original orientation
        m_eye += los * float( fabs( d ) );
        if( send ){
        }
}

void Camera::setDistance( float dist, bool send ){
        Vec3 sub;
        sub = m_eye - m_center;
        sub = normalize( sub );
        m_eye = m_center;
        m_eye += dist * sub;
        if( send ){
        }
}

float Camera::getDistance( void ) const{
        Vec3 sub;
        sub = m_eye - m_center;
        return( length( sub ) );
}

void Camera::move( const Vec3 & v, bool send ){ 
        float w,h;
        if( m_type == ORTHO ){
                if( m_mode & DRAG ){
                        Vec2 v2 = Vec2( v[0] / m_screen[0], v[1] / m_screen[1] );
                        w = getOrthoWidthZoomed();
                        h = getOrthoHeightZoomed();
                        m_ortho[0] += v2[0] * w;
                        m_ortho[1] += v2[0] * w;
                        m_ortho[2] += v2[1] * h;
                        m_ortho[3] += v2[1] * h;
                        bind();
                }
                if( m_mode & ( ZOOM | TRACK | DOLLY ) ){
                        Vec2 v2 = Vec2( v[0] / m_screen[0], v[1] / m_screen[1] + 1.0 );
                        m_zoom *= fabs( v2[1] );
                        bind();
                }
                if( m_mode & ORBIT ){
                        Vec3 sub;
                        float tmp,d;

                        Vec3 v2 = Vec3( v[0] < -50.0 ? -50.0 : v[0] > 50.0 ? 50.0 : v[0],
                                                        v[1] < -50.0 ? -50.0 : v[1] > 50.0 ? 50.0 : v[1],
                                                        v[2] < -50.0 ? -50.0 : v[2] > 50.0 ? 50.0 : v[2] );

                        sub = m_eye - m_center;
                        d = length( sub );

                        if( d < 100.0 ){
                                v2 *= ( d / 100.0 );
                        }

                        sub = normalize( sub );

                        tmp = 1.0 - fabs( sub[2] );
                        // damp the motion in the direction of the poles
                        if( tmp <= 0.1 && v[1] * sub[2] > 0.0f ){
                                tmp *= 10.0;
                                v2 *= tmp;
                        }
                        m_eye = m_eye;
                        m_eye += v2[0] * m_local.getCol(1).xyz();
                        m_eye += v2[1] * m_local.getCol(2).xyz();

                        sub = m_eye - m_center;
                        sub = normalize( sub );

                        m_eye = sub * d;
                        m_eye += m_center;

                        bind();
                }
        }
        else{
                Vec3 sub;
                float tmp,d;
                if( m_mode & ORBIT ){

                        Vec3 v2 = Vec3( v[0] < -50.0 ? -50.0 : v[0] > 50.0 ? 50.0 : v[0],
                                                        v[1] < -50.0 ? -50.0 : v[1] > 50.0 ? 50.0 : v[1],
                                                        v[2] < -50.0 ? -50.0 : v[2] > 50.0 ? 50.0 : v[2] );

                        sub = m_eye - m_center;
                        d = length( sub );

                        if( d < 100.0 ){
                                v2 *= ( d / 100.0 );
                        }

                        sub = normalize( sub );
                        tmp = 1.0 - fabs( sub[2] );
                        // damp the motion in the direction of the poles
                        if( tmp <= 0.1 && v[1] * sub[2] > 0.0f ){
                                tmp *= 10.0;
                                v2 *= tmp;
                        }

                        m_eye += Vec3( v2[0] * m_local.getCol(1).xyz() );
                        m_eye += Vec3( v2[1] * m_local.getCol(2).xyz() );
                        sub = m_eye - m_center;
                        sub = normalize( sub );

                        m_eye = sub * d;
                        m_eye += m_center;
                }
                if( m_mode & DRAG ){
                        sub = m_eye - m_center;
                        d = length( sub );
                        Vec3 v2( v );
                        if( d < 100.0 ){
                                v2 *= ( d / 100.0f );
                        }
                        m_center += v2[0] * m_local.getCol(1).xyz();
                        m_center += v2[1] * m_local.getCol(2).xyz();
                        m_eye += v2[0] * m_local.getCol(1).xyz();
                        m_eye += v2[1] * m_local.getCol(2).xyz();
                }
                if( m_mode & DOLLY ){
                        m_center += v[1] * m_local.getCol(0).xyz();
                        m_eye += v[1] * m_local.getCol(0).xyz();
                }
                if( m_mode & TRACK ){
                        m_eye += v[1] * m_local.getCol(0).xyz();
                }
                if( m_mode & ROLL ){
                        Vec2 v2 = Vec2( v[0] / m_screen[0], v[1] / m_screen[1] + 1.0 );
                        m_roll *= fabs( v2[1] );
                }
                if( m_mode & ZOOM ){
                        Vec2 v2 = Vec2( v[0] / m_screen[0], v[1] / m_screen[1] + 1.0 );
                        m_fovy *= fabs( v2[1] );
                }
        }
        if( send ){
        }
}

void Camera::reshape( int w, int h, bool send ){ 
        initViewport( Vec2( (float)w, (float)h ), send );
}

void Camera::onBind( int unit ){ 

        s_current = dynamic_pointer_cast< Camera, AbstractProperty >( getSharedPtr< AbstractProperty >() );

        Error::assertNoErrors( __FILE__, __LINE__ );

        Vec3 x( m_center - m_eye );
        x = normalize( x );
        Vec3 y( -x[1], x[0], 0.0 );
        if( length( y ) < 0.001f ){
                y[0] = -1.0;
                y[1] =  0.0;
                y[2] =  0.0;
        }

        Vec3 z = cross( x, y );
        z = normalize( z );
        z = Vec3::fromAxisAngle( z, x, float( ( m_roll / 180.0f ) * M_PI ) );

        m_local.setCol( 0, Vec4( normalize( x ), 0.0f ) );
        m_local.setCol( 1, Vec4( normalize( y ), 0.0f ) );
        m_local.setCol( 2, Vec4( normalize( z ), 0.0f ) );

        Error::assertNoErrors( __FILE__, __LINE__ );

        if( m_flip || m_flop ){
                Mat4 identity;
                if( m_flip ){
                        identity[0] = -1.0f;
                }
                if( m_flop ){
                        identity[5] = -1.0f;
                }
                set( PROJECTION, *identity );
        }

        Error::assertNoErrors( __FILE__, __LINE__ );

        glViewport( (GLint)m_vp[0], (GLint)m_vp[1], (GLint)m_vp[2], (GLint)m_vp[3]);

        set( PROJECTION, Mat4::fromIdentity() );
        set( MODELVIEW, Mat4::fromIdentity() );

        Error::assertNoErrors( __FILE__, __LINE__ );

        if( m_type == ORTHO ){

                GLfloat l, r, b, t, x, y;
                float f = 0.5 * m_zoom;

                x = m_ortho[0] + getOrthoWidth() * 0.5;
                y = m_ortho[2] + getOrthoHeight() * 0.5;

                l = x - getOrthoWidth() * f;
                r = x + getOrthoWidth() * f;
                b = y - getOrthoHeight() * f;
                t = y + getOrthoHeight() * f;

                set( PROJECTION, Mat4::fromOrtho( l, r, b, t, m_nearc, m_farc ) );
        }
        else{
                set( PROJECTION, Mat4::fromPerspective( m_fovy * m_zoom, m_aspect, m_nearc, m_farc ) );
                
        }

        Mat4 m = get( MODELVIEW );
        m.lookAt( m_eye, m_center, z );
        set( MODELVIEW, m );

        Error::assertNoErrors( __FILE__, __LINE__ );

        Vec3 n = m_local.getCol(0).xyz();
        Vec3 v = m_eye + ( m_nearc + 0.1f ) * n;

        m_nearPlane = Vec4( n[0], n[1], n[2], 0.0f );
        m_nearPlane[3] = dot( v, n );

        Error::assertNoErrors( __FILE__, __LINE__ );
}

void Camera::drawGrid( int size, int stp ){

#ifndef RT_GLES
        glMatrixMode( GL_PROJECTION );
        glLoadMatrixf( * get( PROJECTION ) );
        glMatrixMode( GL_MODELVIEW );
        glLoadMatrixf( * get( MODELVIEW ) );

        glDisable( GL_TEXTURE_2D );
#ifdef GL_ALPHA_TEST 
        glDisable( GL_ALPHA_TEST );
#endif
#ifdef GL_BLEND 
        glEnable( GL_BLEND );
#endif
        glDepthMask( GL_FALSE );
        glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA ); 

#ifdef GL_LINES 
        glBegin( GL_LINES );
#endif

        // draw the axes
        glColor3f( 1.0, 0.0, 0.0 );
        glVertex3i( 0, 0, 0 );
        glVertex3i( stp, 0, 0 );
        glColor3f( 0.0, 1.0, 0.0 );
        glVertex3i( 0, 0, 0 );
        glVertex3i( 0, stp, 0 );
        glColor3f( 0.0, 0.0, 1.0 );
        glVertex3i( 0, 0, 0 );
        glVertex3i( 0, 0, stp );

        glColor4f( 0.0, 0.0, 0.0, 0.2 );

        for( int i = -size; i <= size; i += stp ){
                glVertex2i( i, -size );
                glVertex2i( i,  size );
        }
        for( int i = -size; i <= size; i += stp ){
                glVertex2i( -size, i );
                glVertex2i(  size, i );
        }
        glEnd();
#endif // OpenGL|ES
}

void Camera::onPropertyEvent( const PropertyEvent & e ){

}
void Camera::onUnbind( int unit ){
        set( PROJECTION, Mat4::fromIdentity() );
        set( MODELVIEW, Mat4::fromIdentity() );
}

void Camera::onInitialize( void ){

}

void Camera::setMode( CamMode mode, bool send ){ 
        m_mode = mode; 
        if( send ){
        }
}

const int Camera::getMode( void ) const { 
        return( m_mode );
}

void  Camera::setType( CamType type, bool send ){ 
        m_type = type;  
        if( send ){
        }
}

const Camera::CamType Camera::getType( void ) const { 
        return( m_type );
}

void Camera::setFOV( float s, bool send ){ 
        m_fovy = s;  
        if( send ){
        }
}

const float Camera::getFOV( void ) const { 
        return( m_fovy );
}

void Camera::setNear( float s, bool send ){ 
        m_nearc = s;  
        if( send ){
        }
}

const float Camera::getNear( void ) const { 
        return( m_nearc );
}

void Camera::setFar( float s, bool send ){ 
        m_farc = s; 
        if( send ){
        }
}

const float Camera::getFar( void ) const { 
        return( m_farc );
}

void Camera::setEye( const Vec3 & v, bool send ){
        m_eye = v;
        if( send ){
        }
}

const Vec3 & Camera::getEye( void ) const { 
        return( m_eye );
}

void Camera::setCenter( const Vec3 & v, bool send ){ 
        m_center = v;
        if( send ){
        }
}

const Vec3 & Camera::getCenter( void ) const { 
        return( m_center );
}

void Camera::setRoll( float deg, bool send ){ 
        m_roll = deg;
        if( send ){
        }
}

const float  Camera::getRoll( void ) const { 
        return( m_roll );
}

void Camera::setFlip( bool state, bool send ){ 
        m_flip = state;
        if( send ){
        }
}

const bool Camera::getFlip( void ) const { 
        return( m_flip );
}

void Camera::setFlop( bool state, bool send ){ 
        m_flop = state; 
        if( send ){
        }
}

const bool Camera::getFlop( void ) const { 
        return( m_flop );
}

const Vec4 & Camera::getViewport( void ) const{ 
        return( m_vp );
}

void Camera::setViewport( const Vec4 & vp, bool send ){ 
        m_vp = vp;
        glViewport( (GLint)m_vp[0], (GLint)m_vp[1], (GLint)m_vp[2], (GLint)m_vp[3] );
        m_aspect = (float)m_vp[2] / (float)m_vp[3];
        if( send ){
        }
}

void Camera::setScreen( const Vec2 & screen, bool send ){ 
        m_screen = screen;
        m_aspect = screen[0] / screen[1];
        if( send ){
        }
}

const Vec2 & Camera::getScreen( void ) const { 
        return( m_screen );
}

void Camera::pushMode( void ){ 
        m_modePushed = m_mode;
}

void Camera::popMode( void ){ 
        m_mode = m_modePushed;
}

bool Camera::clipNear( Vec3 & l1, Vec3 & l2 ){
        // get the distance to the plane
        float d1 = dot( m_nearPlane.xyz(), l1 ) - m_nearPlane[3];
        float d2 = dot( m_nearPlane.xyz(), l2 ) - m_nearPlane[3];
        // if both are negative, both would be clipped 
        if( d1 <= 0.0f && d2 <= 0.0f )return( false );
        // if the points are on oppostite sides of the plane, clip
        if( d1 * d2 <= 0.0f ){
                Vec3 x1 = l1;
                Vec3 x2 = l2;
                float fd1 = fabs(d1);
                float fd2 = fabs(d2);
                if( fd1 + fd2 != 0.0f ){ 
                        float s = fd1 / ( fd1 + fd2 );
                        x2 = l2 * s;
                        x2 += l1 * float( 1.0 -  s );
                        if( d1 <= 0.0f ){
                                x1 = l2;
                        }
                        else{
                                x1 = l1;
                        }
                }
                l1 = x1;
                l2 = x2;
        }
        return( true );
}
Rectangle Camera::project( const NAABB & naabb ){
        // this is the rectangle to return
        Rectangle rect;

#ifndef RT_GLES
        int i = 0;
        Vec3 corner[8];
        Vec3 center = naabb.getCenter();
        for( i = 0; i < 8; i++ ){
                corner[i] = naabb.getCorner( i );
        }

        i = 0;  
        // get the 12 edges of the box as linesegments
        Vec3 segments[12][2];   
        segments[i][0] = corner[ 0 ];
        segments[i][1] = corner[ 1 ]; i++;
        segments[i][0] = corner[ 1 ];
        segments[i][1] = corner[ 2 ]; i++;
        segments[i][0] = corner[ 2 ];
        segments[i][1] = corner[ 3 ]; i++;
        segments[i][0] = corner[ 3 ];
        segments[i][1] = corner[ 0 ]; i++;
        segments[i][0] = corner[ 4 ];
        segments[i][1] = corner[ 5 ]; i++;
        segments[i][0] = corner[ 5 ];
        segments[i][1] = corner[ 6 ]; i++;
        segments[i][0] = corner[ 6 ];
        segments[i][1] = corner[ 7 ]; i++;
        segments[i][0] = corner[ 7 ];
        segments[i][1] = corner[ 4 ]; i++;
        segments[i][0] = corner[ 0 ];
        segments[i][1] = corner[ 4 ]; i++;
        segments[i][0] = corner[ 1 ];
        segments[i][1] = corner[ 5 ]; i++;
        segments[i][0] = corner[ 2 ];
        segments[i][1] = corner[ 6 ]; i++;
        segments[i][0] = corner[ 3 ];
        segments[i][1] = corner[ 7 ];
        // get the transformationmatrices
        GLint vp[4];
        glGetIntegerv( GL_VIEWPORT, vp );

        GLdouble pm[16];
        GLdouble mm[16];

        glGetDoublev( GL_MODELVIEW_MATRIX, mm );
        glGetDoublev( GL_PROJECTION_MATRIX, pm );

#       if gluProject
        GLdouble _wx = 0.0;
        GLdouble _wy = 0.0;
        GLdouble _wz = 0.0;
        
        // run through the linesegs and clip them
        for( i = 0; i < 12; i++ ){
                if( clipNear( segments[i][0], segments[i][1] ) ){
                        for( j = 0; j < 2; j++ ){
                                // project and adjust the rectangle
                                gluProject( segments[i][j][0], segments[i][j][1], segments[i][j][2], mm, pm, vp, &_wx, &_wy, &_wz );
                                if( _wx < rect[0] )rect[0] = _wx;
                                if( _wx > rect[1] )rect[1] = _wx;
                                if( _wy < rect[2] )rect[2] = _wy;
                                if( _wy > rect[3] )rect[3] = _wy;
                        }
                }
        }
#       endif
#elif WIN32
#       pragma message( "warning: Camera::project() not implemented under OpenGL|ES" )
#endif

        return( rect );
}

Rectangle Camera::project( const AABB & _aabb, const Mat4 & mat ){
        Rectangle rect;
#ifndef RT_GLES
        int i = 0;
        Vec4 corner[8];
        Vec3 center( (float)mat[12], (float)mat[13], (float)mat[14] );
        // get the 8 corners of the box
        for( i = 0; i < 8; i++ ){
                corner[i] = mat * Vec4( _aabb.getCorner( i ) );
        }
        i = 0;  
        // get the 12 edges of the box as linesegments
        Vec4 segments[12][2];   
        segments[i][0] = corner[ 0 ];
        segments[i][1] = corner[ 1 ]; i++;
        segments[i][0] = corner[ 1 ];
        segments[i][1] = corner[ 2 ]; i++;
        segments[i][0] = corner[ 2 ];
        segments[i][1] = corner[ 3 ]; i++;
        segments[i][0] = corner[ 3 ];
        segments[i][1] = corner[ 0 ]; i++;
        segments[i][0] = corner[ 4 ];
        segments[i][1] = corner[ 5 ]; i++;
        segments[i][0] = corner[ 5 ];
        segments[i][1] = corner[ 6 ]; i++;
        segments[i][0] = corner[ 6 ];
        segments[i][1] = corner[ 7 ]; i++;
        segments[i][0] = corner[ 7 ];
        segments[i][1] = corner[ 4 ]; i++;
        segments[i][0] = corner[ 0 ];
        segments[i][1] = corner[ 4 ]; i++;
        segments[i][0] = corner[ 1 ];
        segments[i][1] = corner[ 5 ]; i++;
        segments[i][0] = corner[ 2 ];
        segments[i][1] = corner[ 6 ]; i++;
        segments[i][0] = corner[ 3 ];
        segments[i][1] = corner[ 7 ];

        // get the transformationmatrices
        GLint vp[4];
        glGetIntegerv( GL_VIEWPORT, vp );

        GLdouble pm[16];
        GLdouble mm[16];

        glGetDoublev( GL_MODELVIEW_MATRIX, mm );
        glGetDoublev( GL_PROJECTION_MATRIX, pm );

#       if gluProject
        GLdouble _wx, _wy, _wz;
        // run through the linesegs and clip them
        for( i = 0; i < 12; i++ ){
                if( clipNear( segments[i][0].xyz(), segments[i][1].xyz() ) ){
                        for( int j = 0; j < 2; j++ ){
                                // project and adjust the rectangle
                                gluProject( segments[i][j][0], segments[i][j][1], segments[i][j][2], mm, pm, vp, &_wx, &_wy, &_wz );
                                if( _wx < rect[0] )rect[0] = _wx;
                                if( _wx > rect[1] )rect[1] = _wx;
                                if( _wy < rect[2] )rect[2] = _wy;
                                if( _wy > rect[3] )rect[3] = _wy;
                        }
                }
        }
#       endif
#elif WIN32
#       pragma message( "warning: Camera::project() not implemented under OpenGL|ES 2.0" )
#endif

        return( rect );
}

Rectangle Camera::project( const Vec3 & p, float r ){
        Vec3 rv = Vec3( r, r, r );
        NAABB naabb( p - rv, p + rv );
        return( project( naabb ) );
}

void Camera::setOrthoWidth( float x, float y, float w, bool send ){ 
        m_ortho[0] = x;
        m_ortho[1] = x + w;
        m_ortho[2] = y;
        m_ortho[3] = w / m_aspect;
        if( send ){
        }
}

void Camera::setOrthoHeight( float x, float y, float h, bool send ){ 
        m_ortho[0] = x;
        m_ortho[1] = h * m_aspect;
        m_ortho[2] = y;
        m_ortho[3] = y + h;
        if( send ){
        }
}

void Camera::setOrtho( const Vec4 & ortho, bool send ){ 
        m_ortho = ortho;
        if( send ){
        }
}

const Vec4 & Camera::getOrtho( void ) const{
        return( m_ortho );
}

Vec4 & Camera::getOrtho( void ){
        return( m_ortho );
}

Vec4 Camera::getOrthoZoomed( void ) const{ 
        float x,y;
        float f = 0.5f * m_zoom;

        x = m_ortho[0] + getOrthoWidth() * 0.5f;
        y = m_ortho[2] + getOrthoHeight() * 0.5f;

        Vec4 r;
        r[0] = x - getOrthoWidth() * f;
        r[1] = x + getOrthoWidth() * f;
        r[2] = y - getOrthoHeight() * f;
        r[3] = y + getOrthoHeight() * f;

        return( r );
}

float Camera::getOrthoWidth( void ) const { 
        return( m_ortho[1] - m_ortho[0] );
}

float Camera::getOrthoHeight( void ) const { 
        return( m_ortho[3] - m_ortho[2] );
}

float Camera::getOrthoWidthZoomed( void ) const { 
        return(( m_ortho[1] - m_ortho[0] ) * m_zoom );
}

float Camera::getOrthoHeightZoomed( void ) const { 
        return( ( m_ortho[3] - m_ortho[2] ) * m_zoom );
}


void Camera::rectZoom( const Vec2 & p1, const Vec2 & p2, bool send ){ 
        GLint vp[4];
        glGetIntegerv( GL_VIEWPORT, vp );
        m_vp[0] = vp[0];
        m_vp[1] = vp[1];
        m_vp[2] = vp[2];
        m_vp[3] = vp[3];

        float l1, r1, b1, t1, w1, h1;
        float l2, r2, b2, t2, w2, h2;

        l1 = ( p1[0] < p2[0] ) ? p1[0] : p2[0];
        r1 = ( p1[0] > p2[0] ) ? p1[0] : p2[0];
        b1 = ( p1[1] < p2[1] ) ? p1[1] : p2[1];
        t1 = ( p1[1] > p2[1] ) ? p1[1] : p2[1];

        w1 = r1 - l1 + 1;
        h1 = t1 - b1 + 1;

        if( m_type == PERSPECTIVE ){
        }
        else{
                if( w1 > h1 ){
                        l2 = l1;
                        r2 = r1;

                        m_aspect = (float)m_vp[2] / (float)m_vp[3];
                        h2 = m_aspect * w1;
                        b2 = ( b1 + 0.5 * h1 ) - 0.5 * h2;
                        t2 = ( b1 + 0.5 * h1 ) + 0.5 * h2;                      
                }
                else{
                        t2 = t1;
                        b2 = b1;

                        m_aspect = (float)m_vp[2] / (float)m_vp[3];
                        w2 = m_aspect * h1;
                        l2 = ( l1 + 0.5 * w1 ) - 0.5 * w2;
                        r2 = ( l1 + 0.5 * w1 ) + 0.5 * w2;
                }
                m_ortho[0]      = l2;
                m_ortho[1]      = r2;
                m_ortho[2]      = b2;
                m_ortho[3]      = t2;
        }
        if( send ){
        }
}

Vec3 Camera::screen2Global( const Vec3 & screen ){
#ifndef RT_GLES
        //
        //      the screenVector 'in' is assumed to be
        //      aligned upward from the bottom of the screen
        //                      
        //              +---------+
        //              |         |
        //              |   +     |
        //      +y      |  /      |
        //        ^     | /       |
        //        |     |/        |
        //        |     +---------+
        //        o-----> +x
        
        GLdouble pm[16], ret[3], screend[3] = { screen[0], screen[1], screen[2] };
        GLdouble mm[16];
        GLint vp[4] = { (GLint)m_vp[0], (GLint)m_vp[1], (GLint)m_vp[2], (GLint)m_vp[3] };

        glGetDoublev( GL_MODELVIEW_MATRIX, mm );
        glGetDoublev( GL_PROJECTION_MATRIX, pm );

        gluUnProject( screend[0], screend[1], screend[2], mm, pm, vp, &ret[0], &ret[1], &ret[2] );
        return( Vec3( ret[0], ret[1], ret[2] ) );
#elif WIN32
#       pragma message( "warning: Sampler::render() not implemented under OpenGL|ES" )
#endif
        return( Vec3() );
}

void Camera::getProjectionPyramid( Vec3& p1, Vec3& p2, Vec3& p3, Vec3& p4, Vec3& apex, Vec3& m1, Vec3& m2 ){
        // m1 and m2 define a rectangle in opengl screencoords

        float l = ( m1[0] < m2[0] ) ? m1[0] : m2[0];
        float r = ( m1[0] > m2[0] ) ? m1[0] : m2[0];
        float b = ( m1[1] < m2[1] ) ? m1[1] : m2[1];
        float t = ( m1[1] > m2[1] ) ? m1[1] : m2[1];

        m1 = Vec3( l, b, 1.0f );
        m2 = Vec3( r, t, 1.0f );

        Vec3 c1( m2[0], m1[1], 1.0f );
        Vec3 c2( m1[0], m2[1], 1.0f );

        p1 = screen2Global( m1 );
        p2 = screen2Global( c1 );
        p3 = screen2Global( m2 );
        p4 = screen2Global( c2 );

        apex = m_eye;
}

void Camera::initViewport( const Vec2 & vp, bool send ){ 
        setScreen( vp, false );
        setViewport( Vec4( 0.0f, 0.0f, vp ), send );
}


}; // namespace

---