CameraNode.cc

/* ========================================================================= *
 *                                                                           *
 *                               OpenFlipper                                 *
 *           Copyright (c) 2001-2015, RWTH-Aachen University                 *
 *           Department of Computer Graphics and Multimedia                  *
 *                          All rights reserved.                             *
 *                            www.openflipper.org                            *
 *                                                                           *
 *---------------------------------------------------------------------------*
 * This file is part of OpenFlipper.                                         *
 *---------------------------------------------------------------------------*
 *                                                                           *
 * Redistribution and use in source and binary forms, with or without        *
 * modification, are permitted provided that the following conditions        *
 * are met:                                                                  *
 *                                                                           *
 * 1. Redistributions of source code must retain the above copyright notice, *
 *    this list of conditions and the following disclaimer.                  *
 *                                                                           *
 * 2. Redistributions in binary form must reproduce the above copyright      *
 *    notice, this list of conditions and the following disclaimer in the    *
 *    documentation and/or other materials provided with the distribution.   *
 *                                                                           *
 * 3. Neither the name of the copyright holder nor the names of its          *
 *    contributors may be used to endorse or promote products derived from   *
 *    this software without specific prior written permission.               *
 *                                                                           *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS       *
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED *
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A           *
 * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER *
 * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,  *
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,       *
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR        *
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF    *
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING      *
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS        *
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.              *
 *                                                                           *
 * ========================================================================= */
 
/*===========================================================================*\
 *
 *   $Revision$
 *   $Date$
 *
\*===========================================================================*/
 
 
 
 
 
//=============================================================================
//
//  CLASS GlutPrimitiveNode - IMPLEMENTATION
//
//=============================================================================
 
#define CAMERAVISNODE_C
 
//== INCLUDES =================================================================
#include "CameraNode.hh"
 
#include <OpenMesh/Core/Utils/vector_cast.hh>
 
#include <ACG/GL/IRenderer.hh>
#include <ACG/GL/ShaderCache.hh>
#include <ACG/ShaderUtils/GLSLShader.hh>
 
//== NAMESPACES ===============================================================
 
namespace ACG {
namespace SceneGraph {
 
//== IMPLEMENTATION ==========================================================
 
CameraNode::CameraNode(BaseNode* _parent, std::string _name) :
    BaseNode(_parent, _name),
    bbmin_(FLT_MAX,FLT_MAX,FLT_MAX),
    bbmax_(FLT_MIN,FLT_MIN,FLT_MIN),
    cylinder_(0),
    cone_(0),
    axis_length_(0.1f),
    update_vbo_(true),
    offsetTris_(0),
    offsetLines_(0),
    offsetFront_(0),
    showFrustum_(false) {
 
    modelView_.identity();
 
    projection_.identity();
    // Setup a standard projection ( Full fovy 90, aspect 1.0, near 1.0, far 2.0 )
    projection_.perspective(45 ,1.0,1.0,2.0);
 
 
    cylinder_ = new GLCylinder(8, 4, 1.0f, false, false);
    cone_ = new GLCone(8, 1, 1.0f, 0.0f, true, false);
}
 
CameraNode::~CameraNode() {
  if (cylinder_)
    delete cylinder_;
 
  if (cone_)
    delete cone_;
}
 
void CameraNode::boundingBox(Vec3d& _bbMin, Vec3d& _bbMax) {
  _bbMin.minimize(bbmin_);
  _bbMax.maximize(bbmax_);
}
 
//----------------------------------------------------------------------------
 
DrawModes::DrawMode CameraNode::availableDrawModes() const {
    return (DrawModes::POINTS |
            DrawModes::WIREFRAME |
            DrawModes::HIDDENLINE |
            DrawModes::SOLID_FLAT_SHADED |
            DrawModes::SOLID_SMOOTH_SHADED);
}
 
//----------------------------------------------------------------------------
 
void CameraNode::draw(GLState& _state, const DrawModes::DrawMode& /*_drawMode*/) {
 
    glPushAttrib(GL_LIGHTING_BIT);
    glPushAttrib(GL_ENABLE_BIT);
    ACG::GLState::shadeModel(GL_SMOOTH);
    ACG::GLState::enable(GL_LIGHTING); // Turn lighting on
 
    // Store modelview matrix
    _state.push_modelview_matrix();
 
    Vec4f lastBaseColor     = _state.base_color();
    Vec4f lastDiffuseColor  = _state.diffuse_color();
    Vec4f lastSpecularColor = _state.specular_color();
 
    _state.set_base_color(ACG::Vec4f(1.0f, 1.0f, 1.0f, 1.0f));
    _state.set_diffuse_color(ACG::Vec4f(1.0f, 1.0f, 1.0f, 1.0f));
    _state.set_specular_color(ACG::Vec4f(1.0f, 1.0f, 0.0f, 1.0f));
 
    // Draw camera box
 
    updateVBO();
 
    vbo_.bind();
    ibo_.bind();
 
    glPushAttrib(GL_LIGHTING_BIT);
    ACG::GLState::disable(GL_LIGHTING); // Disable lighting
 
    vdecl_.activateFixedFunction();
 
 
    bool hasOrigin = projection_.isPerspective();
    GLsizei lineOffset = offsetLines_;
 
 
    if (showFrustum_)
    {
      // tris
      glColor4f(0.66f, 0.66f, 0.66f, 1.0f);
 
      glDrawElements(GL_TRIANGLES, lineOffset, GL_UNSIGNED_INT, (GLvoid*)(offsetTris_ * sizeof(int)));
 
      // lines
      GLsizei lineCount = hasOrigin ? 4 * 7 : 4 * 6;
 
      glColor4f(0.0f, 0.0f, 0.0f, 1.0f);
      glDrawElements(GL_LINES, lineCount * 2, GL_UNSIGNED_INT, (GLvoid*)(lineOffset * sizeof(int)));
    }
    else
    {
      glColor4f(0.0f, 0.0f, 0.0f, 1.0f);
 
      // only front plane
      GLsizei lineCount = hasOrigin ? 4 * 2 : 4 * 1;
 
      glDrawElements(GL_LINES, lineCount * 2, GL_UNSIGNED_INT, (GLvoid*)(offsetFront_ * sizeof(int)));
    }
 
 
    vdecl_.deactivateFixedFunction();
 
    glPopAttrib();
 
 
    vbo_.unbind();
    ibo_.unbind();
 
 
    // Coordinate axes
 
    _state.set_modelview(_state.modelview() * modelViewInv_);
 
 
    // Draw right vector
    _state.rotate(90, 0.0, 1.0, 0.0);
 
    _state.set_base_color(ACG::Vec4f(1.0f, 0.0f, 0.0f, 1.0f));
    _state.set_diffuse_color(ACG::Vec4f(1.0f, 0.0f, 0.0f, 1.0f));
    _state.set_specular_color(ACG::Vec4f(1.0f, 0.4f, 0.4f, 1.0f));
 
    cylinder_->setBottomRadius(axis_length_/20.0f);
    cylinder_->setTopRadius(axis_length_/20.0f);
    cylinder_->draw(_state, axis_length_);
 
    // Draw top
    _state.translate(0.0, 0.0, axis_length_ );
    cone_->setBottomRadius(axis_length_/5.0f);
    cone_->setTopRadius(0.0f);
    cone_->draw(_state, axis_length_/2.0f);
    _state.translate(0.0, 0.0, -axis_length_ );
 
    // Draw up vector
    _state.rotate(-90, 1.0, 0.0, 0.0);
 
    _state.set_base_color(ACG::Vec4f(0.0f, 1.0f, 0.0f, 1.0f));
    _state.set_diffuse_color(ACG::Vec4f(0.0f, 1.0f, 0.0f, 1.0f));
    _state.set_specular_color(ACG::Vec4f(0.4f, 1.0f, 0.4f, 1.0f));
 
    cylinder_->draw(_state, axis_length_);
 
    // Draw top
    _state.translate(0.0, 0.0, axis_length_ );
    cone_->draw(_state, axis_length_/2.0f);
    _state.translate(0.0, 0.0, -axis_length_ );
 
    // Draw viewing direction vector
    _state.rotate(-90, 0.0, 1.0, 0.0);
 
    _state.set_base_color(ACG::Vec4f(0.0f, 0.0f, 1.0f, 1.0f));
    _state.set_diffuse_color(ACG::Vec4f(0.0f, 0.0f, 1.0f, 1.0f));
    _state.set_specular_color(ACG::Vec4f(0.4f, 0.4f, 1.0f, 1.0f));
 
    cylinder_->draw(_state, axis_length_);
 
    // Draw top
    _state.translate(0.0, 0.0, axis_length_ );
    cone_->draw(_state, axis_length_/2.0f);
    _state.translate(0.0, 0.0, -axis_length_ );
 
 
    // Reset to previous modelview
    _state.pop_modelview_matrix();
 
    _state.set_base_color(lastBaseColor);
    _state.set_diffuse_color(lastDiffuseColor);
    _state.set_specular_color(lastSpecularColor);
 
    glPopAttrib(); // GL_ENABLE_BIT
    glPopAttrib(); // LIGHTING
}
 
//----------------------------------------------------------------------------
 
void CameraNode::getRenderObjects(IRenderer* _renderer, GLState& _state, const DrawModes::DrawMode& _drawMode, const Material* _mat)
{
  updateVBO();
 
  RenderObject obj;
  obj.initFromState(&_state);
  obj.depthTest = true;
  obj.shaderDesc.shadeMode = SG_SHADE_UNLIT;
 
 
  obj.vertexBuffer = vbo_.id();
  obj.indexBuffer = ibo_.id();
  obj.vertexDecl = &vdecl_;
 
  bool hasOrigin = projection_.isPerspective();
 
  GLsizei lineOffset = offsetLines_;
 
  if (showFrustum_)
  {
    // tris
    obj.debugName = "CameraNode.frustum_tris";
    obj.emissive = Vec3f(0.66f, 0.66f, 0.66f);
    obj.glDrawElements(GL_TRIANGLES, lineOffset, GL_UNSIGNED_INT, (GLvoid*)(offsetTris_ * sizeof(int)));
 
    obj.depthRange = Vec2f(0.01f, 1.0f);
    _renderer->addRenderObject(&obj);
 
 
    // lines
    GLsizei lineCount = hasOrigin ? 4 * 7 : 4 * 6;
 
    obj.debugName = "CameraNode.frustum_lines";
    obj.emissive = Vec3f(0.0f, 0.0f, 0.0f);
 
    obj.depthRange = Vec2f(0.0f, 1.0f);
 
    obj.setupLineRendering(_state.line_width(), Vec2f(_state.viewport_width(), _state.viewport_height()));
 
    obj.glDrawElements(GL_LINES, lineCount * 2, GL_UNSIGNED_INT, (GLvoid*)(lineOffset * sizeof(int)));
    _renderer->addRenderObject(&obj);
 
    obj.resetLineRendering();
  }
  else
  {
    obj.debugName = "CameraNode.frustum_lines";
    obj.emissive = Vec3f(0.0f, 0.0f, 0.0f);
 
    // only front plane
    GLsizei lineCount = hasOrigin ? 4 * 2 : 4 * 1;
 
    obj.setupLineRendering(_state.line_width(), Vec2f(_state.viewport_width(), _state.viewport_height()));
 
    obj.glDrawElements(GL_LINES, lineCount * 2, GL_UNSIGNED_INT, (GLvoid*)(offsetFront_ * sizeof(int)));
    _renderer->addRenderObject(&obj);
    obj.resetLineRendering();
  }
 
 
  obj.vertexBuffer = 0;
  obj.indexBuffer = 0;
  obj.vertexDecl = 0;
 
 
  // draw coordinate axis
  cylinder_->setBottomRadius(axis_length_/20.0f);
  cylinder_->setTopRadius(axis_length_/20.0f);
 
  cone_->setBottomRadius(axis_length_/5.0f);
  cone_->setTopRadius(0.0f);
 
  GLMatrixd matView = obj.modelview * modelViewInv_;
 
  // right vec
  obj.debugName = "CameraNode.right_vec";
  obj.emissive = Vec3f(1.0f, 0.0f, 0.0f);
  obj.diffuse = Vec3f(1.0f, 0.0f, 0.0f);
  obj.ambient = Vec3f(1.0f, 0.0f, 0.0f);
  obj.specular = Vec3f(1.0f, 0.4f, 0.4f);
 
  obj.modelview = matView;
  obj.modelview.rotateY(90.0);
  obj.modelview.scale(Vec3d(1.0, 1.0, axis_length_));
  cylinder_->addToRenderer_primitive(_renderer, &obj);
 
  // right top
  obj.debugName = "CameraNode.right_top";
  obj.modelview = matView;
  obj.modelview.rotateY(90.0);
  obj.modelview.translate(Vec3d(0.0, 0.0, axis_length_));
  obj.modelview.scale(Vec3d(1.0, 1.0, axis_length_ * 0.5));
  cone_->addToRenderer_primitive(_renderer, &obj);
 
 
  // up vec
  obj.debugName = "CameraNode.up_vec";
  obj.emissive = Vec3f(0.0f, 1.0f, 0.0f);
  obj.diffuse = Vec3f(0.0f, 1.0f, 0.0f);
  obj.ambient = Vec3f(0.0f, 1.0f, 0.0f);
  obj.specular = Vec3f(0.4f, 1.0f, 0.4f);
 
  obj.modelview = matView;
  obj.modelview.rotateX(-90.0);
  obj.modelview.scale(Vec3d(1.0, 1.0, axis_length_));
  cylinder_->addToRenderer_primitive(_renderer, &obj);
 
  // up top
  obj.debugName = "CameraNode.up_top";
  obj.modelview = matView;
  obj.modelview.rotateX(-90.0);
  obj.modelview.translate(Vec3d(0.0, 0.0, axis_length_));
  obj.modelview.scale(Vec3d(1.0, 1.0, axis_length_ * 0.5));
  cone_->addToRenderer_primitive(_renderer, &obj);
 
 
 
  // Draw viewing direction vector
  obj.debugName = "CameraNode.view_vec";
  obj.emissive = Vec3f(0.0f, 0.0f, 1.0f);
  obj.diffuse = Vec3f(0.0f, 0.0f, 1.0f);
  obj.ambient = Vec3f(0.0f, 0.0f, 1.0f);
  obj.specular = Vec3f(0.4f, 0.4f, 1.0f);
 
  obj.modelview = matView;
  obj.modelview.scale(Vec3d(1.0, 1.0, axis_length_));
  cylinder_->addToRenderer_primitive(_renderer, &obj);
 
  // top
  obj.debugName = "CameraNode.view_top";
  obj.modelview = matView;
  obj.modelview.translate(Vec3d(0.0, 0.0, axis_length_));
  obj.modelview.scale(Vec3d(1.0, 1.0, axis_length_ * 0.5));
  cone_->addToRenderer_primitive(_renderer, &obj);
}
 
//----------------------------------------------------------------------------
 
void CameraNode::pick(GLState& _state, PickTarget /*_target*/)
{
  _state.pick_set_maximum(2);
 
 
  updateVBO();
 
  vbo_.bind();
  ibo_.bind();
 
 
  static ShaderGenDesc desc;
  desc.vertexTemplateFile = "Picking/vertex.glsl";
  desc.fragmentTemplateFile = "Picking/single_color_fs.glsl";
  GLSL::Program* pickShader = ACG::ShaderCache::getInstance()->getProgram(&desc, nullptr);
 
  if (pickShader && pickShader->isLinked())
  {
    pickShader->use();
 
    // world view projection matrix
    GLMatrixf matFrustum = _state.projection() * _state.modelview();
    pickShader->setUniform("mWVP", matFrustum);
 
    Vec4f pickColor = _state.pick_get_name_color_norm(0);
    pickShader->setUniform("color", pickColor);
 
 
 
    // pick frustum
 
    vdecl_.activateShaderPipeline(pickShader);
 
    GLsizei lineOffset = offsetLines_;
 
    if (showFrustum_)
      glDrawElements(GL_TRIANGLES, lineOffset, GL_UNSIGNED_INT, (GLvoid*)(offsetTris_ * sizeof(int)));
    else
    {
      bool hasOrigin = projection_.isPerspective();
      GLsizei lineCount = hasOrigin ? 4 * 2 : 4 * 1;
 
      glDrawElements(GL_LINES, lineCount * 2, GL_UNSIGNED_INT, (GLvoid*)(offsetFront_ * sizeof(int)));
    }
 
 
    vdecl_.deactivateShaderPipeline(pickShader);
 
 
    // pick coordinate axis
    pickColor = _state.pick_get_name_color_norm(1);
    pickShader->setUniform("color", pickColor);
 
 
    cylinder_->setBottomRadius(axis_length_/20.0f);
    cylinder_->setTopRadius(axis_length_/20.0f);
 
    cone_->setBottomRadius(axis_length_/5.0f);
    cone_->setTopRadius(0.0f);
 
 
    GLMatrixf matVP = matFrustum * modelViewInv_;
    GLMatrixf mat;
 
    // right vec
    mat = matVP;
    mat.rotateY(90.0);
    mat.scale(Vec3f(1.0, 1.0, axis_length_));
    pickShader->setUniform("mWVP", mat);
    cylinder_->draw_primitive(pickShader);
 
    // right top
    mat = matVP;
    mat.rotateY(90.0);
    mat.translate(Vec3f(0.0, 0.0, axis_length_));
    mat.scale(Vec3f(1.0, 1.0, axis_length_ * 0.5));
    pickShader->setUniform("mWVP", mat);
    cone_->draw_primitive(pickShader);
 
 
    // up vec
    mat = matVP;
    mat.rotateX(-90.0);
    mat.scale(Vec3f(1.0, 1.0, axis_length_));
    pickShader->setUniform("mWVP", mat);
    cylinder_->draw_primitive(pickShader);
 
    // up top
    mat = matVP;
    mat.rotateX(-90.0);
    mat.translate(Vec3f(0.0, 0.0, axis_length_));
    mat.scale(Vec3f(1.0, 1.0, axis_length_ * 0.5));
    pickShader->setUniform("mWVP", mat);
    cone_->draw_primitive(pickShader);
 
 
 
    // Draw viewing direction vector
    mat = matVP;
    mat.scale(Vec3f(1.0, 1.0, axis_length_));
    pickShader->setUniform("mWVP", mat);
    cylinder_->draw_primitive(pickShader);
 
    // top
    mat = matVP;
    mat.translate(Vec3f(0.0, 0.0, axis_length_));
    mat.scale(Vec3f(1.0, 1.0, axis_length_ * 0.5));
    pickShader->setUniform("mWVP", mat);
    cone_->draw_primitive(pickShader);
 
 
 
 
    pickShader->disable();
  }
  else
  {
    _state.pick_set_name(0);
 
    // Store modelview matrix
    _state.push_modelview_matrix();
 
    // Draw camera box
    bool hasOrigin = projection_.isPerspective();
    GLsizei lineOffset = offsetLines_;
 
 
    vbo_.bind();
    ibo_.bind();
 
    vdecl_.activateFixedFunction();
 
    if (showFrustum_)
    {
      // tris
      glDrawElements(GL_TRIANGLES, lineOffset, GL_UNSIGNED_INT, (GLvoid*)(offsetTris_ * sizeof(int)));
 
      // lines
      GLsizei lineCount = hasOrigin ? 4 * 7 : 4 * 6;
      glDrawElements(GL_LINES, lineCount * 2, GL_UNSIGNED_INT, (GLvoid*)(lineOffset * sizeof(int)));
    }
    else
    {
      // only front plane
      GLsizei lineCount = hasOrigin ? 4 * 2 : 4 * 1;
 
      glDrawElements(GL_LINES, lineCount * 2, GL_UNSIGNED_INT, (GLvoid*)(offsetFront_ * sizeof(int)));
    }
 
    vdecl_.deactivateFixedFunction();
 
    ibo_.unbind();
    vbo_.unbind();
 
 
    // Set modelview matrix such that it matches
    // the remote settings (+ the local transformation).
    // This is performed by multiplying the local
    // modelview matrix by the inverse remote
    // modelview matrix: M_l' = M_l * M^{-1}_r
    _state.set_modelview(_state.modelview() * modelViewInv_);
 
    _state.pick_set_name(1);
 
    // Draw right vector
    _state.rotate(90, 0.0, 1.0, 0.0);
 
    cylinder_->setBottomRadius(axis_length_/20.0f);
    cylinder_->setTopRadius(axis_length_/20.0f);
    cylinder_->draw(_state, axis_length_);
 
    // Draw top
    _state.translate(0.0, 0.0, axis_length_ );
    cone_->setBottomRadius(axis_length_/5.0f);
    cone_->setTopRadius(0.0f);
    cone_->draw(_state, axis_length_/2.0f);
    _state.translate(0.0, 0.0, -axis_length_ );
 
    // Draw up vector
    _state.rotate(-90, 1.0, 0.0, 0.0);
 
    cylinder_->draw(_state, axis_length_);
 
    // Draw top
    _state.translate(0.0, 0.0, axis_length_ );
    cone_->draw(_state, axis_length_/2.0f);
    _state.translate(0.0, 0.0, -axis_length_ );
 
    // Draw viewing direction vector
    _state.rotate(-90, 0.0, 1.0, 0.0);
 
    cylinder_->draw(_state, axis_length_);
 
    // Draw top
    _state.translate(0.0, 0.0, axis_length_ );
    cone_->draw(_state, axis_length_/2.0f);
    _state.translate(0.0, 0.0, -axis_length_ );
 
    // Reset to previous modelview
    _state.pop_modelview_matrix();
  }
 
  vbo_.unbind();
  ibo_.unbind();
}
 
//----------------------------------------------------------------------------
 
void CameraNode::updateVBO()
{
  if (update_vbo_)
  {
    updateFrustumWS();
 
    vbo_.bind();
    vbo_.upload(sizeof(Vec4f) * vboData_.size(), &vboData_[0], GL_STATIC_DRAW);
    vbo_.unbind();
 
    vdecl_.clear();
    vdecl_.addElement(GL_FLOAT, 4, VERTEX_USAGE_POSITION);
 
    update_vbo_ = false;
 
    updateBoundingBoxes();
  }
 
  if (!ibo_.is_valid())
  {
    int data[] =
    {
      // frustum triangles (planes facing the inside of the frustum)
      3,2,6 , 6,5,3 , // right
      1,0,4 , 4,7,1 , // left
      4,5,6 , 6,7,4 , // top
      0,1,2 , 2,3,0 , // bottom
      0,3,5 , 5,4,0 , // back
//      2,1,7 , 7,6,2 , // front
 
      // frustum lines
      3,2, 2,6, 6,5, 5,3, // right
      1,0, 0,4, 4,7, 7,1, // left
      4,5, 5,6, 6,7, 7,4, // top
      0,1, 1,2, 2,3, 3,0, // bottom
      0,3, 3,5, 5,4, 4,0, // back
      2,1, 1,7, 7,6, 6,2, // front
 
      // cam origin to near plane lines
      8,1, 8,2, 8,6, 8,7
    };
 
    offsetTris_ = 0;
    offsetLines_ = 6*5;
    offsetFront_ = offsetLines_ + 8*5;
 
    ibo_.bind();
    ibo_.upload(sizeof(data), data, GL_STATIC_DRAW);
    ibo_.unbind();
  }
}
 
//----------------------------------------------------------------------------
 
void CameraNode::updateBoundingBoxes()
{
  bbmin_ = Vec3d(DBL_MAX, DBL_MAX, DBL_MAX);
  bbmax_ = Vec3d(-DBL_MAX, -DBL_MAX, -DBL_MAX);
 
  if (update_vbo_ || vboData_.empty())
    updateFrustumWS();
 
  for (size_t i = 0; i < vboData_.size(); ++i)
  {
    Vec3d v = OpenMesh::vector_cast<Vec3d, Vec4f>(vboData_[i]);
 
    bbmin_.minimize(v);
    bbmax_.maximize(v);
  }
 
  bbmin_ -= Vec3d(axis_length_ * 2.0);
  bbmax_ += Vec3d(axis_length_ * 2.0);
}
 
//----------------------------------------------------------------------------
 
void CameraNode::updateFrustumWS()
{
  vboData_.resize(9);
 
  // frustum vertices in clip space
  Vec4f posCS[8] =
  {
    Vec4f(-1, -1, 1, 1),  //0  frustum vertices..
    Vec4f(-1, -1, -1, 1), //1
    Vec4f(1, -1, -1, 1),  //2
    Vec4f(1, -1, 1, 1),   //3
    Vec4f(-1, 1, 1, 1),   //4
    Vec4f(1, 1, 1, 1),    //5
    Vec4f(1, 1, -1, 1),   //6
    Vec4f(-1, 1, -1, 1),  //7
  };
 
  // transform to world space
 
  GLMatrixf camWorldToClip = projection_ * modelView_;
 
  GLMatrixf camClipToWorld(camWorldToClip);
  camClipToWorld.invert();
 
  for (int i= 0; i < 8; ++i)
  {
    Vec4f posWS = camClipToWorld * posCS[i];
    posWS /= posWS[3];
    vboData_[i] = posWS;
  }
 
  // camera position in world space
  Vec4f camOriginWS(modelViewInv_(0, 3),
    modelViewInv_(1, 3),
    modelViewInv_(2, 3),
    1.0f);
 
  vboData_[8] = camOriginWS;
 
 
  // make axis length relative to frustum size in world space
  Vec3f rightVec = OpenMesh::vector_cast<Vec3f, Vec4f>(vboData_[3] - vboData_[0]);
  Vec3f upVec = OpenMesh::vector_cast<Vec3f, Vec4f>(vboData_[7] - vboData_[1]);
  axis_length_ = std::min(rightVec.norm(), upVec.norm()) * 0.015f;
 
  // minimum axis length
  axis_length_ = std::max(axis_length_, 0.05f);
}
 
 
 
//=============================================================================
} // namespace SceneGraph
} // namespace ACG
//=============================================================================