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(); }