From Cedric Pinson, first cut at Producer .cfg camera configuration file support.
This commit is contained in:
Robert Osfield
776
src/osgPlugins/cfg/Camera.cpp
Normal file
776
src/osgPlugins/cfg/Camera.cpp
Normal file
@@ -0,0 +1,776 @@
|
||||
/* -*-c++-*- Producer - Copyright (C) 2001-2004 Don Burns
|
||||
*
|
||||
* This library is open source and may be redistributed and/or modified under
|
||||
* the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or
|
||||
* (at your option) any later version. The full license is in LICENSE file
|
||||
* included with this distribution, and on the openscenegraph.org website.
|
||||
*
|
||||
* This library is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* OpenSceneGraph Public License for more details.
|
||||
*/
|
||||
|
||||
#ifdef WIN32
|
||||
#include <windows.h>
|
||||
#endif
|
||||
|
||||
#include <string.h>
|
||||
#include <algorithm>
|
||||
|
||||
#include "Camera.h"
|
||||
|
||||
using namespace osgProducer;
|
||||
|
||||
Camera::Camera( void )
|
||||
{
|
||||
_index = 0;
|
||||
|
||||
_projrectLeft = 0.0;
|
||||
_projrectRight = 1.0;
|
||||
_projrectBottom = 0.0;
|
||||
_projrectTop = 1.0;
|
||||
|
||||
osg::Matrix::value_type id[] = {
|
||||
1, 0, 0, 0,
|
||||
0, 1, 0, 0,
|
||||
0, 0, 1, 0,
|
||||
0, 0, 0, 1
|
||||
};
|
||||
|
||||
memcpy( _viewMatrix, id, sizeof(osg::Matrix::value_type[16]));
|
||||
_offset._xshear = _offset._yshear = 0.0f;
|
||||
memcpy( _offset._matrix, id, sizeof(osg::Matrix::value_type[16]));
|
||||
_offset._multiplyMethod = Offset::PreMultiply;
|
||||
|
||||
_lens = new Lens;
|
||||
_lens->setAutoAspect(true);
|
||||
_rs = new RenderSurface;
|
||||
|
||||
_clear_color[0] = 0.2f;
|
||||
_clear_color[1] = 0.2f;
|
||||
_clear_color[2] = 0.4f;
|
||||
_clear_color[3] = 1.0f;
|
||||
|
||||
_focal_distance = 1.0;
|
||||
|
||||
_shareLens = true;
|
||||
_shareView = true;
|
||||
|
||||
_enabled = true;
|
||||
_initialized = false;
|
||||
|
||||
}
|
||||
|
||||
Camera::~Camera( void )
|
||||
{
|
||||
}
|
||||
|
||||
|
||||
const osg::Matrix::value_type * Camera::getViewMatrix( void ) const
|
||||
{
|
||||
return _viewMatrix;
|
||||
}
|
||||
|
||||
void Camera::setViewByMatrix( const osg::Matrix &mat )
|
||||
{
|
||||
osg::Matrix m;
|
||||
if ( _offset._multiplyMethod == Offset::PostMultiply )
|
||||
m = osg::Matrix( _offset._matrix ) * mat;
|
||||
else if( _offset._multiplyMethod == Offset::PreMultiply )
|
||||
m = mat * osg::Matrix( _offset._matrix );
|
||||
memcpy( _viewMatrix, m.ptr(), sizeof( osg::Matrix::value_type[16] ));
|
||||
}
|
||||
|
||||
void Camera::setViewByLookat( const osg::Vec3 &eye, const osg::Vec3 ¢er, const osg::Vec3 &up )
|
||||
{
|
||||
osg::Matrix m;
|
||||
m.makeLookAt(eye,center,up);
|
||||
setViewByMatrix( m );
|
||||
}
|
||||
|
||||
void Camera::setViewByLookat( float eyeX, float eyeY, float eyeZ,
|
||||
float centerX, float centerY, float centerZ,
|
||||
float upX, float upY, float upZ )
|
||||
{
|
||||
setViewByLookat( osg::Vec3(eyeX, eyeY, eyeZ),
|
||||
osg::Vec3(centerX, centerY, centerZ ),
|
||||
osg::Vec3(upX, upY, upZ) );
|
||||
}
|
||||
|
||||
|
||||
Camera::Lens::Lens( void )
|
||||
{
|
||||
// original defaults.
|
||||
// _left = -0.5;
|
||||
// _right = 0.5;
|
||||
// _bottom = -0.5;
|
||||
// _top = 0.5;
|
||||
|
||||
// Setting of the frustum which are appropriate for
|
||||
// a monitor which is 26cm high, 50cm distant from the
|
||||
// viewer and an horzintal/vetical aspect ratio of 1.25.
|
||||
// This assumed to be a reasonable average setting for end users.
|
||||
_left = -0.32;
|
||||
_right = 0.32;
|
||||
_bottom = -0.26;
|
||||
_top = 0.26;
|
||||
_ortho_left = -1.0;
|
||||
_ortho_right = 1.0;
|
||||
_ortho_bottom = -1.0;
|
||||
_ortho_top = 1.0;
|
||||
_nearClip = 1.0;
|
||||
_farClip = 1e6;
|
||||
_updateFOV();
|
||||
_projection = Perspective;
|
||||
}
|
||||
|
||||
void Camera::Lens::setAspectRatio( double aspectRatio )
|
||||
{
|
||||
_aspect_ratio = aspectRatio;
|
||||
_left = -0.5 * (_top - _bottom) * _aspect_ratio;
|
||||
_right = 0.5 * (_top - _bottom) * _aspect_ratio;
|
||||
_ortho_left = -0.5 * (_ortho_top - _ortho_bottom) * _aspect_ratio;
|
||||
_ortho_right = 0.5 * (_ortho_top - _ortho_bottom) * _aspect_ratio;
|
||||
|
||||
if( _projection == Perspective )
|
||||
_updateFOV();
|
||||
}
|
||||
|
||||
void Camera::Lens::setPerspective( double hfov, double vfov,
|
||||
double nearClip, double farClip )
|
||||
{
|
||||
_hfov = osg::DegreesToRadians(hfov);
|
||||
_vfov = osg::DegreesToRadians(vfov);
|
||||
_aspect_ratio = tan(0.5*_hfov)/tan(0.5*_vfov);
|
||||
|
||||
_nearClip = nearClip;
|
||||
_farClip = farClip;
|
||||
|
||||
_left = -_nearClip * tan(_hfov/2.0);
|
||||
_right = _nearClip * tan(_hfov/2.0);
|
||||
_bottom = -_nearClip * tan(_vfov/2.0);
|
||||
_top = _nearClip * tan(_vfov/2.0);
|
||||
|
||||
_projection = Perspective;
|
||||
setAutoAspect(false);
|
||||
}
|
||||
|
||||
void Camera::Lens::setFrustum( double left, double right,
|
||||
double bottom, double top,
|
||||
double nearClip, double farClip )
|
||||
{
|
||||
_left = left;
|
||||
_right = right;
|
||||
_bottom = bottom;
|
||||
_top = top;
|
||||
_nearClip = nearClip;
|
||||
_farClip = farClip;
|
||||
_projection = Perspective;
|
||||
_updateFOV();
|
||||
setAutoAspect(false);
|
||||
}
|
||||
|
||||
void Camera::Lens::setOrtho( double left, double right,
|
||||
double bottom, double top,
|
||||
double nearClip, double farClip )
|
||||
{
|
||||
_ortho_left = left;
|
||||
_ortho_right = right;
|
||||
_ortho_bottom = bottom;
|
||||
_ortho_top = top;
|
||||
_nearClip = nearClip;
|
||||
_farClip = farClip;
|
||||
_projection = Orthographic;
|
||||
setAutoAspect(false);
|
||||
}
|
||||
|
||||
void Camera::Lens::setMatrix( const osg::Matrix::value_type matrix[16] )
|
||||
{
|
||||
memcpy( _matrix, matrix, sizeof(osg::Matrix::value_type[16]) );
|
||||
_projection = Manual;
|
||||
setAutoAspect(false);
|
||||
}
|
||||
|
||||
bool Camera::Lens::getFrustum( double& left, double& right,
|
||||
double& bottom, double& top,
|
||||
double& zNear, double& zFar ) const
|
||||
{
|
||||
//The following code was taken from osg's matrix implementation of getFrustum
|
||||
if (_matrix[3]!=0.0 || _matrix[7]!=0.0 || _matrix[11]!=-1.0 || _matrix[15]!=0.0) return false;
|
||||
|
||||
zNear = _matrix[14] / (_matrix[10]-1.0);
|
||||
zFar = _matrix[14] / (1.0+_matrix[10]);
|
||||
|
||||
left = zNear * (_matrix[8]-1.0) / _matrix[0];
|
||||
right = zNear * (1.0+_matrix[8]) / _matrix[0];
|
||||
|
||||
top = zNear * (1.0+_matrix[9]) / _matrix[5];
|
||||
bottom = zNear * (_matrix[9]-1.0) / _matrix[5];
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool Camera::Lens::getOrtho( double& left, double& right,
|
||||
double& bottom, double& top,
|
||||
double& zNear, double& zFar ) const
|
||||
{
|
||||
//The following code was taken from osg's matrix implementation of getOrtho
|
||||
if (_matrix[3]!=0.0 || _matrix[7]!=0.0 || _matrix[11]!=0.0 || _matrix[15]!=1.0) return false;
|
||||
|
||||
zNear = (_matrix[14]+1.0) / _matrix[10];
|
||||
zFar = (_matrix[14]-1.0) / _matrix[10];
|
||||
|
||||
left = -(1.0+_matrix[12]) / _matrix[0];
|
||||
right = (1.0-_matrix[12]) / _matrix[0];
|
||||
|
||||
bottom = -(1.0+_matrix[13]) / _matrix[5];
|
||||
top = (1.0-_matrix[13]) / _matrix[5];
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool Camera::Lens::convertToOrtho( float d )
|
||||
{
|
||||
|
||||
if( _projection == Manual )
|
||||
{
|
||||
//Need to extract frustum values from manual matrix
|
||||
if( !getFrustum(_left,_right,_bottom,_top,_nearClip,_farClip) )
|
||||
return false;
|
||||
|
||||
_updateFOV();
|
||||
}
|
||||
|
||||
double s = d * tan(_vfov*0.5);
|
||||
_ortho_bottom = -s;
|
||||
_ortho_top = s;
|
||||
_ortho_left = -s*_aspect_ratio;
|
||||
_ortho_right = s*_aspect_ratio;
|
||||
_projection = Orthographic;
|
||||
return true;
|
||||
}
|
||||
|
||||
bool Camera::Lens::convertToPerspective( float d )
|
||||
{
|
||||
|
||||
if( _projection == Manual )
|
||||
{
|
||||
//Need to extract ortho values from manual matrix
|
||||
if( !getOrtho(_ortho_left,_ortho_right,_ortho_bottom,_ortho_top,_nearClip,_farClip) )
|
||||
return false;
|
||||
}
|
||||
|
||||
double hfov = 2 * atan( 0.5 * (_ortho_right - _ortho_left)/d);
|
||||
double vfov = 2 * atan( 0.5 * (_ortho_top - _ortho_bottom)/d);
|
||||
|
||||
_left = -_nearClip * tan(hfov*0.5);
|
||||
_right = _nearClip * tan(hfov*0.5);
|
||||
_bottom = -_nearClip * tan(vfov*0.5);
|
||||
_top = _nearClip * tan(vfov*0.5);
|
||||
|
||||
_projection = Perspective;
|
||||
//_updateMatrix();
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
void Camera::Lens::apply(float xshear, float yshear)
|
||||
{
|
||||
osg::Matrix::value_type _matrix[16];
|
||||
generateMatrix(xshear,yshear,_matrix);
|
||||
}
|
||||
|
||||
void Camera::Lens::getParams( double &left, double &right, double &bottom, double &top,
|
||||
double &nearClip, double &farClip )
|
||||
{
|
||||
if( _projection == Perspective )
|
||||
{
|
||||
left = _left;
|
||||
right = _right;
|
||||
bottom = _bottom;
|
||||
top = _top;
|
||||
}
|
||||
else if( _projection == Orthographic )
|
||||
{
|
||||
left = _ortho_left;
|
||||
right = _ortho_right;
|
||||
bottom = _ortho_bottom;
|
||||
top = _ortho_top;
|
||||
}
|
||||
else if( _projection == Manual ) // could only be Manual, but best to make this clear
|
||||
{
|
||||
// Check if Manual matrix is either a valid perspective or orthographic matrix
|
||||
// If neither, then return bogus values -- nothing better we can do
|
||||
if(getFrustum(left,right,bottom,top,nearClip,farClip))
|
||||
return;
|
||||
|
||||
if(getOrtho(left,right,bottom,top,nearClip,farClip))
|
||||
return;
|
||||
|
||||
left = _left;
|
||||
right = _right;
|
||||
bottom = _bottom;
|
||||
top = _top;
|
||||
}
|
||||
nearClip = _nearClip;
|
||||
farClip = _farClip;
|
||||
}
|
||||
|
||||
void Camera::setProjectionRectangle( const float left, const float right,
|
||||
const float bottom, const float top )
|
||||
{
|
||||
_projrectLeft = left;
|
||||
_projrectRight = right;
|
||||
_projrectBottom = bottom;
|
||||
_projrectTop = top;
|
||||
}
|
||||
|
||||
void Camera::getProjectionRectangle( float &left, float &right,
|
||||
float &bottom, float &top ) const
|
||||
{
|
||||
left = _projrectLeft;
|
||||
right = _projrectRight;
|
||||
bottom = _projrectBottom;
|
||||
top = _projrectTop;
|
||||
}
|
||||
|
||||
void Camera::setProjectionRectangle( int x, int y, unsigned int width, unsigned int height )
|
||||
{
|
||||
int _x, _y;
|
||||
unsigned int _w, _h;
|
||||
|
||||
_rs->getWindowRectangle( _x, _y, _w, _h );
|
||||
#if 0
|
||||
if( _w == osgProducer::RenderSurface::UnknownDimension || _h == Producer::RenderSurface::UnknownDimension)
|
||||
{
|
||||
unsigned int ww;
|
||||
unsigned int hh;
|
||||
_rs->getScreenSize( ww, hh );
|
||||
if( _w == osgProducer::RenderSurface::UnknownDimension )
|
||||
_w = ww;
|
||||
if( _h == osgProducer::RenderSurface::UnknownDimension )
|
||||
_h = hh;
|
||||
}
|
||||
#endif
|
||||
|
||||
_projrectLeft = float(x - _x)/float(_w);
|
||||
_projrectRight = float((x + width) - _x)/float(_w);
|
||||
_projrectBottom = float(y - _y)/float(_h);
|
||||
_projrectTop = float((y+height) - _y)/float(_h);
|
||||
}
|
||||
|
||||
void Camera::getProjectionRectangle( int &x, int &y, unsigned int &width, unsigned int &height ) const
|
||||
{
|
||||
int _x, _y;
|
||||
unsigned int _w, _h;
|
||||
float fx, fy, fw, fh;
|
||||
|
||||
_rs->getWindowRectangle( _x, _y, _w, _h );
|
||||
#if 0
|
||||
if( _w == Producer::RenderSurface::UnknownDimension || _h == Producer::RenderSurface::UnknownDimension )
|
||||
{
|
||||
unsigned int ww;
|
||||
unsigned int hh;
|
||||
_rs->getScreenSize( ww, hh );
|
||||
if( _w == Producer::RenderSurface::UnknownDimension )
|
||||
_w = ww;
|
||||
if( _h == Producer::RenderSurface::UnknownDimension )
|
||||
_h = hh;
|
||||
}
|
||||
#endif
|
||||
|
||||
fx = _projrectLeft * _w;
|
||||
fy = _projrectBottom * _h;
|
||||
fw = _w * _projrectRight;
|
||||
fh = _h * _projrectTop;
|
||||
|
||||
x = int(fx);
|
||||
y = int(fy);
|
||||
|
||||
width = int(fw) - x;
|
||||
height = int(fh) - y;
|
||||
}
|
||||
|
||||
void Camera::setClearColor( float r, float g, float b, float a )
|
||||
{
|
||||
_clear_color[0] = r;
|
||||
_clear_color[1] = g;
|
||||
_clear_color[2] = b;
|
||||
_clear_color[3] = a;
|
||||
}
|
||||
|
||||
void Camera::getClearColor( float& red, float& green, float& blue, float& alpha)
|
||||
{
|
||||
red = _clear_color[0];
|
||||
green = _clear_color[1];
|
||||
blue = _clear_color[2];
|
||||
alpha = _clear_color[3];
|
||||
}
|
||||
|
||||
|
||||
void Camera::clear( void )
|
||||
{
|
||||
#if 0
|
||||
if( !_initialized ) _initialize();
|
||||
int x, y;
|
||||
unsigned int w, h;
|
||||
getProjectionRectangle( x, y, w, h );
|
||||
glViewport( x, y, w, h );
|
||||
glScissor( x, y, w, h );
|
||||
glClearColor( _clear_color[0], _clear_color[1], _clear_color[2], _clear_color[3] );
|
||||
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT );
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
#if 0
|
||||
void Camera::Lens::_updateMatrix( void )
|
||||
{
|
||||
switch( _projection )
|
||||
{
|
||||
case Perspective :
|
||||
_matrix[ 0] = (2 * _nearClip)/(_right - _left);
|
||||
_matrix[ 1] = 0.0;
|
||||
_matrix[ 2] = 0.0;
|
||||
_matrix[ 3] = 0.0;
|
||||
|
||||
_matrix[ 4] = 0.0;
|
||||
_matrix[ 5] = (2 * _nearClip)/(_top-_bottom);
|
||||
_matrix[ 6] = 0.0;
|
||||
_matrix[ 7] = 0.0;
|
||||
|
||||
_matrix[ 8] = (_right + _left)/(_right-_left);
|
||||
_matrix[ 9] = (_top+_bottom)/(_top-_bottom);
|
||||
_matrix[10] = -(_farClip + _nearClip)/(_farClip-_nearClip);
|
||||
_matrix[11] = -1.0;
|
||||
|
||||
_matrix[12] = 0.0;
|
||||
_matrix[13] = 0.0;
|
||||
_matrix[14] = -(2 * _farClip * _nearClip)/(_farClip-_nearClip);
|
||||
_matrix[15] = 0.0;
|
||||
|
||||
_matrix[ 8] += -_xshear;
|
||||
_matrix[ 9] += -_yshear;
|
||||
|
||||
_hfov = 2.0 * atan(((_right - _left) * 0.5)/_nearClip);
|
||||
_vfov = 2.0 * atan(((_top - _bottom) * 0.5)/_nearClip);
|
||||
|
||||
break;
|
||||
|
||||
case Orthographic :
|
||||
|
||||
_matrix[ 0] = 2/(_ortho_right - _ortho_left);
|
||||
_matrix[ 1] = 0.0;
|
||||
_matrix[ 2] = 0.0;
|
||||
_matrix[ 3] = 0.0;
|
||||
|
||||
_matrix[ 4] = 0.0;
|
||||
_matrix[ 5] = 2/(_ortho_top - _ortho_bottom);
|
||||
_matrix[ 6] = 0.0;
|
||||
_matrix[ 7] = 0.0;
|
||||
|
||||
_matrix[ 8] = 0.0;
|
||||
_matrix[ 9] = 0.0;
|
||||
//_matrix[10] = -2.0/(_farClip - (-_farClip));
|
||||
_matrix[10] = -2.0/(_farClip - _nearClip);
|
||||
_matrix[11] = 0.0;
|
||||
|
||||
_matrix[12] = -(_ortho_right+_ortho_left)/(_ortho_right-_ortho_left);
|
||||
_matrix[13] = -(_ortho_top+_ortho_bottom)/(_ortho_top-_ortho_bottom);
|
||||
//_matrix[14] = -(_farClip+(-_farClip))/(_farClip-(-_farClip));
|
||||
_matrix[14] = -(_farClip+_nearClip)/(_farClip-_nearClip);
|
||||
_matrix[15] = 1.0;
|
||||
|
||||
_matrix[12] += _xshear;
|
||||
_matrix[13] += _yshear;
|
||||
|
||||
//_hfov = 0.0;
|
||||
//_vfov = 0.0;
|
||||
|
||||
break;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
void Camera::Lens::generateMatrix(float xshear, float yshear, osg::Matrix::value_type matrix[16] )
|
||||
{
|
||||
switch( _projection )
|
||||
{
|
||||
case Perspective :
|
||||
matrix[ 0] = (2 * _nearClip)/(_right - _left);
|
||||
matrix[ 1] = 0.0;
|
||||
matrix[ 2] = 0.0;
|
||||
matrix[ 3] = 0.0;
|
||||
|
||||
matrix[ 4] = 0.0;
|
||||
matrix[ 5] = (2 * _nearClip)/(_top-_bottom);
|
||||
matrix[ 6] = 0.0;
|
||||
matrix[ 7] = 0.0;
|
||||
|
||||
matrix[ 8] = (_right + _left)/(_right-_left);
|
||||
matrix[ 9] = (_top+_bottom)/(_top-_bottom);
|
||||
matrix[10] = -(_farClip + _nearClip)/(_farClip-_nearClip);
|
||||
matrix[11] = -1.0;
|
||||
|
||||
matrix[12] = 0.0;
|
||||
matrix[13] = 0.0;
|
||||
matrix[14] = -(2 * _farClip * _nearClip)/(_farClip-_nearClip);
|
||||
matrix[15] = 0.0;
|
||||
|
||||
matrix[ 8] += -xshear;
|
||||
matrix[ 9] += -yshear;
|
||||
|
||||
|
||||
break;
|
||||
|
||||
case Orthographic :
|
||||
|
||||
matrix[ 0] = 2/(_ortho_right - _ortho_left);
|
||||
matrix[ 1] = 0.0;
|
||||
matrix[ 2] = 0.0;
|
||||
matrix[ 3] = 0.0;
|
||||
|
||||
matrix[ 4] = 0.0;
|
||||
matrix[ 5] = 2/(_ortho_top - _ortho_bottom);
|
||||
matrix[ 6] = 0.0;
|
||||
matrix[ 7] = 0.0;
|
||||
|
||||
matrix[ 8] = 0.0;
|
||||
matrix[ 9] = 0.0;
|
||||
//_matrix[10] = -2.0/(_farClip - (-_farClip));
|
||||
matrix[10] = -2.0/(_farClip - _nearClip);
|
||||
matrix[11] = 0.0;
|
||||
|
||||
matrix[12] = -(_ortho_right+_ortho_left)/(_ortho_right-_ortho_left);
|
||||
matrix[13] = -(_ortho_top+_ortho_bottom)/(_ortho_top-_ortho_bottom);
|
||||
//_matrix[14] = -(_farClip+(-_farClip))/(_farClip-(-_farClip));
|
||||
matrix[14] = -(_farClip+_nearClip)/(_farClip-_nearClip);
|
||||
matrix[15] = 1.0;
|
||||
|
||||
matrix[12] += xshear;
|
||||
matrix[13] += yshear;
|
||||
|
||||
break;
|
||||
|
||||
case Manual:
|
||||
|
||||
memcpy( matrix, _matrix, sizeof(osg::Matrix::value_type[16]));
|
||||
|
||||
if(xshear || yshear)
|
||||
{
|
||||
if (matrix[3]!=0.0 || matrix[7]!=0.0 || matrix[11]!=0.0 || matrix[15]!=1.0)
|
||||
{
|
||||
// It's not an orthographic matrix so just assume a perspective shear
|
||||
matrix[ 8] += -xshear;
|
||||
matrix[ 9] += -yshear;
|
||||
}
|
||||
else
|
||||
{
|
||||
matrix[12] += xshear;
|
||||
matrix[13] += yshear;
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
void Camera::Lens::_updateFOV()
|
||||
{
|
||||
_hfov = 2.0 * atan(((_right - _left) * 0.5)/_nearClip);
|
||||
_vfov = 2.0 * atan(((_top - _bottom) * 0.5)/_nearClip);
|
||||
_aspect_ratio = tan(0.5*_hfov)/tan(0.5*_vfov);
|
||||
}
|
||||
|
||||
|
||||
void Camera::setOffset( const osg::Matrix::value_type matrix[16], double xshear, double yshear )
|
||||
{
|
||||
memcpy( _offset._matrix, matrix, sizeof(osg::Matrix::value_type[16]));
|
||||
_offset._xshear = xshear;
|
||||
_offset._yshear = yshear;
|
||||
}
|
||||
|
||||
void Camera::setOffset( double xshear, double yshear )
|
||||
{
|
||||
_offset._xshear = xshear;
|
||||
_offset._yshear = yshear;
|
||||
}
|
||||
|
||||
#if 0
|
||||
void Camera::setSyncBarrier( RefBarrier *b )
|
||||
{
|
||||
_syncBarrier = b;
|
||||
}
|
||||
|
||||
void Camera::setFrameBarrier( RefBarrier *b )
|
||||
{
|
||||
_frameBarrier = b;
|
||||
}
|
||||
|
||||
int Camera::cancel()
|
||||
{
|
||||
#if 1
|
||||
_done = true;
|
||||
#endif
|
||||
|
||||
Thread::cancel();
|
||||
return 0;
|
||||
}
|
||||
|
||||
void Camera::advance()
|
||||
{
|
||||
_rs->makeCurrent();
|
||||
_rs->swapBuffers();
|
||||
}
|
||||
|
||||
void Camera::run( void )
|
||||
{
|
||||
if( !_syncBarrier.valid() || !_frameBarrier.valid() )
|
||||
{
|
||||
std::cerr << "Camera::run() : Threaded Camera requires a Barrier\n";
|
||||
return;
|
||||
}
|
||||
|
||||
_done = false;
|
||||
|
||||
_initialize();
|
||||
_syncBarrier->block();
|
||||
while( !_done )
|
||||
{
|
||||
// printf(" Camera::run before frame block\n");
|
||||
|
||||
_frameBarrier->block();
|
||||
|
||||
if (_done) break;
|
||||
|
||||
// printf(" Camera::run after frame block\n");
|
||||
|
||||
frame(false);
|
||||
|
||||
if (_done) break;
|
||||
|
||||
// printf(" Camera::run before sycn block\n");
|
||||
|
||||
_syncBarrier->block();
|
||||
|
||||
if (_done) break;
|
||||
|
||||
// printf(" Camera::run after sycn block\n");
|
||||
|
||||
advance();
|
||||
}
|
||||
|
||||
// printf("Exiting Camera::run cleanly\n");
|
||||
}
|
||||
|
||||
|
||||
|
||||
bool Camera::removePreCullCallback( Callback *cb )
|
||||
{
|
||||
return _removeCallback( preCullCallbacks, cb );
|
||||
}
|
||||
|
||||
bool Camera::removePostCullCallback( Callback *cb )
|
||||
{
|
||||
return _removeCallback( postCullCallbacks, cb );
|
||||
}
|
||||
|
||||
bool Camera::removePreDrawCallback( Callback *cb )
|
||||
{
|
||||
return _removeCallback( preDrawCallbacks, cb );
|
||||
}
|
||||
|
||||
bool Camera::removePostDrawCallback( Callback *cb )
|
||||
{
|
||||
return _removeCallback( postDrawCallbacks, cb );
|
||||
}
|
||||
|
||||
bool Camera::removePostSwapCallback( Callback *cb )
|
||||
{
|
||||
return _removeCallback( postSwapCallbacks, cb );
|
||||
}
|
||||
|
||||
|
||||
bool Camera::_removeCallback( std::vector < ref_ptr<Callback> > &callbackList, Callback *callback )
|
||||
{
|
||||
std::vector < Producer::ref_ptr< Producer::Camera::Callback> >::iterator p;
|
||||
p = std::find( callbackList.begin(), callbackList.end(), callback );
|
||||
if( p == callbackList.end() )
|
||||
return false;
|
||||
|
||||
callbackList.erase( p );
|
||||
return true;
|
||||
}
|
||||
|
||||
Camera::FrameTimeStampSet::FrameTimeStampSet():
|
||||
_pipeStatsDoubleBufferIndex(0),
|
||||
_pipeStatsFirstSync(true),
|
||||
_initialized(false)
|
||||
{
|
||||
for( unsigned int i = 0; i < LastPipeStatsID; i++ )
|
||||
_pipeStats[i] = 0.0;
|
||||
}
|
||||
|
||||
Camera::FrameTimeStampSet::~FrameTimeStampSet()
|
||||
{
|
||||
}
|
||||
|
||||
void Camera::FrameTimeStampSet::syncPipeStats()
|
||||
{
|
||||
if( !_initialized )
|
||||
return;
|
||||
|
||||
if( _pipeStatsFirstSync == true )
|
||||
{
|
||||
_pipeStatsFirstSync = false;
|
||||
return;
|
||||
}
|
||||
|
||||
// We get the stats from the previous frame
|
||||
for( int i = 0; i < LastPipeStatsID; i++ )
|
||||
{
|
||||
if( _pipeStatsSetMask[1 - _pipeStatsDoubleBufferIndex] & (1<<i) )
|
||||
_pipeStats[i] = PipeTimer::instance()->getElapsedTime( _pipeStatsNames[i][ 1 - _pipeStatsDoubleBufferIndex] );
|
||||
}
|
||||
|
||||
_pipeStatsFrameNumber = _frameNumber - 1;
|
||||
_pipeStatsDoubleBufferIndex = 1 - _pipeStatsDoubleBufferIndex;
|
||||
_pipeStatsSetMask[_pipeStatsDoubleBufferIndex] = 0;
|
||||
}
|
||||
|
||||
void Camera::FrameTimeStampSet::beginPipeTimer( PipeStatsID id)
|
||||
{
|
||||
if( !_initialized )
|
||||
_init();
|
||||
|
||||
PipeTimer::instance()->begin( _pipeStatsNames[id][_pipeStatsDoubleBufferIndex] );
|
||||
_pipeStatsSetMask[_pipeStatsDoubleBufferIndex] |= (1<<id);
|
||||
}
|
||||
|
||||
void Camera::FrameTimeStampSet::endPipeTimer()
|
||||
{
|
||||
if( !_initialized )
|
||||
return;
|
||||
|
||||
PipeTimer::instance()->end() ;
|
||||
}
|
||||
|
||||
void Camera::FrameTimeStampSet::_init()
|
||||
{
|
||||
if( _initialized )
|
||||
return;
|
||||
|
||||
for( unsigned int i = 0; i < (unsigned int)LastPipeStatsID; i++ )
|
||||
PipeTimer::instance()->genQueries( 2, _pipeStatsNames[i] );
|
||||
|
||||
_pipeStatsSetMask[0] = 0;
|
||||
_pipeStatsSetMask[1] = 0;
|
||||
|
||||
_initialized = true;
|
||||
}
|
||||
|
||||
const Camera::FrameTimeStampSet &Camera::getFrameStats()
|
||||
{
|
||||
return _frameStamps;
|
||||
}
|
||||
#endif
|
||||
Reference in New Issue
Block a user