void Channel::_orderFrames( eq::Frames& frames )
{
eq::Matrix4f modelviewM; // modelview matrix
eq::Matrix3f modelviewITM; // modelview inversed transposed matrix
const FrameData& frameData = _getFrameData();
const eq::Matrix4f& rotation = frameData.getRotation();
if( !useOrtho( ))
_calcMVandITMV( modelviewM, modelviewITM );
orderFrames( frames, modelviewM, modelviewITM, rotation, useOrtho( ));
}
void Channel::_orderImages( eq::ImageOps& images )
{
const FrameData& frameData = _getFrameData();
const eq::Matrix4f& rotation = frameData.getRotation();
const eq::Matrix4f& modelView = useOrtho() ? eq::Matrix4f() :
_computeModelView();
// calculate modelview inversed+transposed matrix
const eq::Matrix4f& modelviewIM = modelView.inverse();
const eq::Matrix3f& modelviewITM =
vmml::transpose( eq::Matrix3f( modelviewIM ));
orderImages( images, modelView, modelviewITM, rotation, useOrtho( ));
}
void Input::draw() {
//text->textToDisplay += line;
//text->textToDisplay = line;
text->textToDisplay = "TEST";
SDL_Rect position;
position.y = (Sint16) (gameSettings->GH/20 * 19);
position.x = (Sint16) (gameSettings->GW/8);
text->setPosition(position);
//fboBegin();
glDrawBuffer(HUD_BUFFER);
// Clear the screen
//glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
//draw the text
glPushMatrix();
useOrtho();
glDisable(GL_CULL_FACE);
glDisable(GL_LIGHTING);
text->draw();
usePerspective();
glPopMatrix();
glEnable(GL_LIGHTING);
//fboEnd();
//SDL_GL_SwapBuffers();
}
void Channel::_orderFrames( eq::Frames& frames )
{
const FrameData& frameData = _getFrameData();
const eq::Matrix4f& rotation = frameData.getRotation();
const eq::Matrix4f& modelView = useOrtho() ? eq::Matrix4f::IDENTITY :
_computeModelView();
//calculate modelview inversed transposed matrix
eq::Matrix3f modelviewITM;
eq::Matrix4f modelviewIM;
modelView.inverse( modelviewIM );
eq::Matrix3f( modelviewIM ).transpose_to( modelviewITM );
orderFrames( frames, modelView, modelviewITM, rotation, useOrtho( ));
}
void Channel::_drawModel( const Model* scene )
{
Window* window = static_cast< Window* >( getWindow( ));
VertexBufferState& state = window->getState();
const FrameData& frameData = _getFrameData();
if( frameData.getColorMode() == COLOR_MODEL && scene->hasColors( ))
state.setColors( true );
else
state.setColors( false );
state.setChannel( this );
// Compute cull matrix
const eq::Matrix4f& rotation = frameData.getCameraRotation();
const eq::Matrix4f& modelRotation = frameData.getModelRotation();
eq::Matrix4f position = eq::Matrix4f::IDENTITY;
position.set_translation( frameData.getCameraPosition());
const eq::Frustumf& frustum = getFrustum();
const eq::Matrix4f projection = useOrtho() ? frustum.compute_ortho_matrix():
frustum.compute_matrix();
const eq::Matrix4f& view = getHeadTransform();
const eq::Matrix4f model = rotation * position * modelRotation;
state.setProjectionModelViewMatrix( projection * view * model );
state.setRange( &getRange().start);
const eq::Pipe* pipe = getPipe();
const GLuint program = state.getProgram( pipe );
if( program != VertexBufferState::INVALID )
glUseProgram( program );
scene->cullDraw( state );
state.setChannel( 0 );
if( program != VertexBufferState::INVALID )
glUseProgram( 0 );
const InitData& initData =
static_cast<Config*>( getConfig( ))->getInitData();
if( initData.useROI( ))
// declare empty region in case nothing is in frustum
declareRegion( eq::PixelViewport( ));
else
declareRegion( getPixelViewport( ));
#ifndef NDEBUG
outlineViewport();
#endif
}
void Channel::_updateNearFar( const mesh::BoundingSphere& boundingSphere )
{
// compute dynamic near/far plane of whole model
const FrameData& frameData = _getFrameData();
const eq::Matrix4f& rotation = frameData.getCameraRotation();
const eq::Matrix4f headTransform = getHeadTransform() * rotation;
eq::Matrix4f modelInv;
compute_inverse( headTransform, modelInv );
const eq::Vector3f zero = modelInv * eq::Vector3f::ZERO;
eq::Vector3f front = modelInv * eq::Vector3f( 0.0f, 0.0f, -1.0f );
front -= zero;
front.normalize();
front *= boundingSphere.w();
const eq::Vector3f center =
frameData.getCameraPosition().get_sub_vector< 3 >() -
boundingSphere.get_sub_vector< 3 >();
const eq::Vector3f nearPoint = headTransform * ( center - front );
const eq::Vector3f farPoint = headTransform * ( center + front );
if( useOrtho( ))
{
LBASSERTINFO( fabs( farPoint.z() - nearPoint.z() ) >
std::numeric_limits< float >::epsilon(),
nearPoint << " == " << farPoint );
setNearFar( -nearPoint.z(), -farPoint.z() );
}
else
{
// estimate minimal value of near plane based on frustum size
const eq::Frustumf& frustum = getFrustum();
const float width = fabs( frustum.right() - frustum.left() );
const float height = fabs( frustum.top() - frustum.bottom() );
const float size = LB_MIN( width, height );
const float minNear = frustum.near_plane() / size * .001f;
const float zNear = LB_MAX( minNear, -nearPoint.z() );
const float zFar = LB_MAX( zNear * 2.f, -farPoint.z() );
setNearFar( zNear, zFar );
}
}
bool ViewData::_handleEvent( const eq::Event& event )
{
switch( event.type )
{
case eq::Event::CHANNEL_POINTER_BUTTON_RELEASE:
{
const eq::PointerEvent& releaseEvent =
event.pointerButtonRelease;
if( releaseEvent.buttons == eq::PTR_BUTTON_NONE )
{
if( releaseEvent.button == eq::PTR_BUTTON1 )
{
_spinX = releaseEvent.dy;
_spinY = releaseEvent.dx;
return true;
}
if( releaseEvent.button == eq::PTR_BUTTON2 )
{
_advance = -releaseEvent.dy;
return true;
}
}
return false;
}
case eq::Event::CHANNEL_POINTER_MOTION:
switch( event.pointerMotion.buttons )
{
case eq::PTR_BUTTON1:
_spinX = 0;
_spinY = 0;
spinModel( -0.005f * event.pointerMotion.dy,
-0.005f * event.pointerMotion.dx, 0.f );
return true;
case eq::PTR_BUTTON2:
_advance = -event.pointerMotion.dy;
moveModel( 0.f, 0.f, .005f * _advance );
return true;
case eq::PTR_BUTTON3:
moveModel( .0005f * event.pointerMotion.dx,
-.0005f * event.pointerMotion.dy, 0.f );
return true;
default:
return false;
}
case eq::Event::CHANNEL_POINTER_WHEEL:
moveModel( -0.05f * event.pointerWheel.xAxis, 0.f,
0.05f * event.pointerWheel.yAxis );
return true;
case eq::Event::MAGELLAN_AXIS:
_spinX = 0;
_spinY = 0;
_advance = 0;
spinModel( 0.0001f * event.magellan.zRotation,
-0.0001f * event.magellan.xRotation,
-0.0001f * event.magellan.yRotation );
moveModel( 0.0001f * event.magellan.xAxis,
-0.0001f * event.magellan.zAxis,
0.0001f * event.magellan.yAxis );
return true;
case eq::Event::KEY_PRESS:
switch( event.keyPress.key )
{
case 's':
showStatistics( !getStatistics( ));
return true;
case 'o':
setOrtho( !useOrtho( ));
return true;
}
return false;
default:
return false;
}
}
void Channel::_drawModel( const Model* scene )
{
Window* window = static_cast< Window* >( getWindow( ));
VertexBufferState& state = window->getState();
const FrameData& frameData = _getFrameData();
if( frameData.getColorMode() == COLOR_MODEL && scene->hasColors( ))
state.setColors( true );
else
state.setColors( false );
state.setChannel( this );
// Compute cull matrix
const eq::Matrix4f& rotation = frameData.getCameraRotation();
const eq::Matrix4f& modelRotation = frameData.getModelRotation();
eq::Matrix4f position = eq::Matrix4f::IDENTITY;
position.set_translation( frameData.getCameraPosition());
const eq::Frustumf& frustum = getFrustum();
const eq::Matrix4f projection = useOrtho() ? frustum.compute_ortho_matrix():
frustum.compute_matrix();
const eq::Matrix4f& view = getHeadTransform();
const eq::Matrix4f model = rotation * position * modelRotation;
state.setProjectionModelViewMatrix( projection * view * model );
state.setRange( &getRange().start);
const eq::Pipe* pipe = getPipe();
const GLuint program = state.getProgram( pipe );
if( program != VertexBufferState::INVALID )
glUseProgram( program );
scene->cullDraw( state );
state.setChannel( 0 );
if( program != VertexBufferState::INVALID )
glUseProgram( 0 );
const InitData& initData =
static_cast<Config*>( getConfig( ))->getInitData();
if( !initData.useROI( ))
{
declareRegion( getPixelViewport( ));
return;
}
#ifndef NDEBUG // region border
const eq::PixelViewport& pvp = getPixelViewport();
const eq::PixelViewport& region = getRegion();
glMatrixMode( GL_PROJECTION );
glLoadIdentity();
glOrtho( 0.f, pvp.w, 0.f, pvp.h, -1.f, 1.f );
glMatrixMode( GL_MODELVIEW );
glLoadIdentity();
const eq::View* currentView = getView();
if( currentView && frameData.getCurrentViewID() == currentView->getID( ))
glColor3f( 0.f, 0.f, 0.f );
else
glColor3f( 1.f, 1.f, 1.f );
glNormal3f( 0.f, 0.f, 1.f );
const eq::Vector4f rect( float( region.x ) + .5f, float( region.y ) + .5f,
float( region.getXEnd( )) - .5f,
float( region.getYEnd( )) - .5f );
glBegin( GL_LINE_LOOP ); {
glVertex3f( rect[0], rect[1], -.99f );
glVertex3f( rect[2], rect[1], -.99f );
glVertex3f( rect[2], rect[3], -.99f );
glVertex3f( rect[0], rect[3], -.99f );
} glEnd();
#endif
}
