void Channel::_updateNearFar( const triply::BoundingSphere& boundingSphere )
{
// compute dynamic near/far plane of whole model
const FrameData& frameData = _getFrameData();
const eq::Matrix4f& rotation = frameData.getCameraRotation();
const eq::Matrix4f& view = getHeadTransform() * rotation;
eq::Matrix4f viewInv;
compute_inverse( view, viewInv );
const eq::Vector3f& zero = viewInv * eq::Vector3f::ZERO;
eq::Vector3f front = viewInv * eq::Vector3f( 0.0f, 0.0f, -1.0f );
front -= zero;
front.normalize();
front *= boundingSphere.w();
const eq::Vector3f& center = frameData.getCameraPosition() -
boundingSphere.get_sub_vector< 3 >();
const eq::Vector3f nearPoint = view * ( center - front );
const eq::Vector3f farPoint = view * ( 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 );
}
}
void Renderer::draw( co::Object* frameDataObj )
{
EQASSERT( _state );
const FrameData* frameData = static_cast< FrameData* >( frameDataObj );
Application& application = static_cast< Application& >( getApplication( ));
const eq::uint128_t id = frameData->getModelID();
const Model* model = application.getModel( id );
if( !model )
return;
applyRenderContext();
glLightfv( GL_LIGHT0, GL_POSITION, lightPosition );
glLightfv( GL_LIGHT0, GL_AMBIENT, lightAmbient );
glLightfv( GL_LIGHT0, GL_DIFFUSE, lightDiffuse );
glLightfv( GL_LIGHT0, GL_SPECULAR, lightSpecular );
glMaterialfv( GL_FRONT, GL_AMBIENT, materialAmbient );
glMaterialfv( GL_FRONT, GL_DIFFUSE, materialDiffuse );
glMaterialfv( GL_FRONT, GL_SPECULAR, materialSpecular );
glMateriali( GL_FRONT, GL_SHININESS, materialShininess );
applyModelMatrix();
glColor3f( .75f, .75f, .75f );
// Compute cull matrix
const eq::Matrix4f& modelM = getModelMatrix();
const eq::Matrix4f& view = getViewMatrix();
const eq::Frustumf& frustum = getFrustum();
const eq::Matrix4f projection = frustum.compute_matrix();
const eq::Matrix4f pmv = projection * view * modelM;
_state->setProjectionModelViewMatrix( pmv );
//_state->setRange( &getRange().start);
_state->setColors( model->hasColors( ));
model->cullDraw( *_state );
}
void Channel::frameDraw(const eq::uint128_t &frame_id)
{
// Setup OpenGL state (view frustum etc.)
eq::Channel::frameDraw(frame_id);
// Get data
const Config *config = static_cast<Config *>(getConfig());
const Node *node = static_cast<Node *>(getNode());
const InitData &init_data = node->getInitData();
const Pipe *pipe = static_cast<Pipe *>(getPipe());
const FrameData &frame_data = pipe->getFrameData();
Window *window = static_cast<Window *>(getWindow());
Ogre::Camera *cam = pipe->_ogre->getCamera();
// Set the projection matrix
const eq::Frustumf & frustum = getFrustum();
cam->setCustomProjectionMatrix(true, toOgreMatrix(frustum.compute_matrix()));
const eq::Matrix4f eqViewMatrix = getHeadTransform();
// Adjust the view matrix according to equalizer's view matrix
Ogre::Matrix4 ogreViewMatrix = toOgreMatrix(eqViewMatrix);
cam->setCustomViewMatrix(true, ogreViewMatrix);
cam->setNearClipDistance(frustum.near_plane());
cam->setFarClipDistance(frustum.far_plane());
// Set the viewport
eq::PixelViewport winPvp = window->getPixelViewport();
eq::PixelViewport pvp = getPixelViewport();
window->setViewport((float)pvp.x/(float)winPvp.w,
1.0f - (float)(pvp.h + pvp.y)/(float)winPvp.h,
(float)pvp.w/(float)winPvp.w,
(float)pvp.h/(float)winPvp.h);
// Render
window->render();
}
/** The rendering routine, a.k.a., glutDisplayFunc() */
void eqHello::Renderer::draw(co::Object* /*frameData*/)
{
applyRenderContext(); // set up OpenGL State
const seq::Matrix4f mvp = getFrustum().computePerspectiveMatrix() *
getViewMatrix() * getModelMatrix();
EQ_GL_CALL(glUseProgram(_program));
EQ_GL_CALL(glUniformMatrix4fv(_matrixUniform, 1, GL_FALSE, mvp.data()));
EQ_GL_CALL(glBindVertexArray(_vertexArray));
EQ_GL_CALL(glEnableVertexAttribArray(0));
EQ_GL_CALL(glEnableVertexAttribArray(1));
EQ_GL_CALL(glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, _indexBuffer));
EQ_GL_CALL(glDrawElements(GL_TRIANGLES, GLsizei(_triangles.size() * 3),
GL_UNSIGNED_SHORT, 0));
EQ_GL_CALL(glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0));
EQ_GL_CALL(glDisableVertexAttribArray(1));
EQ_GL_CALL(glDisableVertexAttribArray(0));
EQ_GL_CALL(glBindVertexArray(0));
EQ_GL_CALL(glUseProgram(0));
}
void Camera::drawDebugGeometry(DebugRenderer* debug)
{
debug->addFrustum(getFrustum(), Color::WHITE);
}
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
}
mat4 Camera::getFrustumMatrix(float windowRatio) const {
Frustum f = getFrustum();
return glm::frustum(f.getLeft() * windowRatio, f.getRight() * windowRatio,
f.getBottom(), f.getTop(),
f.getNearDist(), f.getFarDist());
}
bool Light::isVisible(const Frustum* const frustum) const {
// return frustum == 0 || frustum->testAgainstFrustum(getFrustum()) != TestResult::OUT_SIDE;
return frustum == 0 || getFrustum()->testAgainstFrustum(frustum) != TestResult::OUT_SIDE;
}
void Light::beginClipping(void) const
{
getFrustum().beginClipping();
}
