AnimaL

Tutorial

Documentation

---

Documentation

• Overview
• Modules
• Namespace List
• Class Hierarchy
• Alphabetical List
• Compound List
• File List
• Namespace Members
• Compound Members
• File Members
• Examples

---

frameNode.cpp

Go to the documentation of this file.

#include <cmath>
#include <float.h>
#include <animal/X3DTK/Qt/x3dTransformGUI/x3dTransformQt.h>

#include "frameNode.h"

namespace X3DTK
{
  namespace X3D
  {
    FrameNode::FrameNode()
        : swollen(1.0)
        , x3dTransformNode(0)
        , size(1.0)

    {
      // Defines the tag of the node. This string must be the same than the one
      // entered for the creation function, otherwise the node won't be loaded.
      // Node
      define(Recorder<FrameNode>::getTypeName("FrameNode"));
    }


    FrameNode::~FrameNode()
    {}

    // Init the engine (i.e loading from x3d scene)
    void FrameNode::init()
    {
      //std::cerr<<"FrameNode::initEngine()"<<std::endl;
      MFNode list = getParentList();
      MFNode::iterator i = list.begin();
      if (list.size()==1) // only one parent possible
      {
        if ( Transform * T = dynamic_cast<Transform *>(*i)) // the parent needs to be a transform
        {
          x3dTransformNode = T;
          translation = x3dTransformNode->getTranslation();
          rotation = x3dTransformNode->getRotation();
          scale = x3dTransformNode->getScale();
          scaleOrientation = x3dTransformNode->getScaleOrientation();
          center = x3dTransformNode->getCenter();
          updateFrame();
          // Init the engine
          animal::Engine::init();
          return;
        }
      }
      std::cerr<<std::endl<<"Warning FrameNode::init(): impossible to init a X3DTK::X3D::FrameNode."<<std::endl;
      std::cerr<<"        It has to have only one X3DTK::X3D::Transform as parent."<<std::endl;
    }

    void FrameNode::draw()
    {
      //std::cerr<<"FrameNode::draw()"<<std::endl;
      //     if (x3dTransformNode)
      //     {
      //         glPushAttrib(GL_ALL_ATTRIB_BITS);
      //         glDisable(GL_COLOR_MATERIAL);
      //         glMatrixMode(GL_MODELVIEW);
      //
      //         int nbSub = 8 ;
      //         float length = 1.0 ;
      //         float coneHeight = length / 10.0 ;
      //         float coneBase = length / 30.0 ;
      //         float cylinderHeight = length - 0.7*coneHeight ;
      //         float cylinderBase = coneBase / 4.0 ;
      //         float charWidth = length / 40.0 ;
      //         float charHeight = length / 30.0 ;
      //         float charShift = length + 0.4*coneHeight ;
      //
      //         // Draw the letters
      //         glDisable(GL_LIGHTING);
      //         glColor3f(0.5, 0.5, 0.5);
      //         glLineWidth(2.0);
      //         glPushMatrix();
      //         glScalef(size, size, size);
      //         glBegin(GL_LINES);
      //         // The X
      //         glVertex3f(charShift,  charWidth, -charHeight);
      //         glVertex3f(charShift, -charWidth,  charHeight);
      //         glVertex3f(charShift, -charWidth, -charHeight);
      //         glVertex3f(charShift,  charWidth,  charHeight);
      //         // The Y
      //         glVertex3f( charWidth, charShift, charHeight);
      //         glVertex3f(0.0,        charShift, 0.0);
      //         glVertex3f(-charWidth, charShift, charHeight);
      //         glVertex3f(0.0,        charShift, 0.0);
      //         glVertex3f(0.0,        charShift, 0.0);
      //         glVertex3f(0.0,        charShift, -charHeight);
      //         // The Z
      //         glVertex3f(-charWidth,  charHeight, charShift);
      //         glVertex3f( charWidth,  charHeight, charShift);
      //         glVertex3f( charWidth,  charHeight, charShift);
      //         glVertex3f(-charWidth, -charHeight, charShift);
      //         glVertex3f(-charWidth, -charHeight, charShift);
      //         glVertex3f( charWidth, -charHeight, charShift);
      //         glEnd();
      //         glPopMatrix();
      //         glEnable(GL_LIGHTING);
      //
      //         glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
      //
      //         float color[4];
      //
      //         // X axis
      //         color[0] = 0.7;
      //         color[1] = 0.7;
      //         color[2] = 1.0;
      //         color[3] = 1.0;
      //         glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, color);
      //         glPushMatrix();
      //         glScalef(size, size, size);
      //         drawCylinder(cylinderBase, cylinderHeight, nbSub);
      //         glTranslatef(0.0, 0.0, length-coneHeight);
      //         drawCone(coneBase, coneHeight, nbSub);
      //         glPopMatrix();
      //
      //         // Y axis
      //         color[0] = 1.0;
      //         color[1] = 0.7;
      //         color[2] = 0.7;
      //         color[3] = 1.0;
      //         glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, color);
      //         glPushMatrix();
      //         glRotatef(90.0, 0.0, 1.0, 0.0);
      //         glScalef(size, size, size);
      //         drawCylinder(cylinderBase, cylinderHeight, nbSub);
      //         glTranslatef(0.0, 0.0, length-coneHeight);
      //         drawCone(coneBase, coneHeight, nbSub);
      //         glPopMatrix();
      //
      //         // Z axis
      //         color[0] = 0.7;
      //         color[1] = 1.0;
      //         color[2] = 0.7;
      //         color[3] = 1.0;
      //         glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, color);
      //         glPushMatrix();
      //         glRotatef(-90.0, 1.0, 0.0, 0.0);
      //         glScalef(size, size, size);
      //         drawCylinder(cylinderBase, cylinderHeight, nbSub);
      //         glTranslatef(0.0, 0.0, length-coneHeight);
      //         drawCone(coneBase, coneHeight, nbSub);
      //         glPopMatrix();
      //
      //         //glPopMatrix();
      //         glPopAttrib();
      //
      //     }
    }


    void FrameNode::updateBoundingBox()
    {
      float xmin, ymin, zmin, xmax, ymax, zmax;
      getBoundingBox(xmin, ymin, zmin, xmax, ymax, zmax);
      setBBoxCenter(SFVec3f((xmax+xmin)/2.0, (ymax+ymin)/2.0, (zmax+zmin)/2.0));
      setBBoxSize(SFVec3f(xmax-xmin, ymax-ymin, zmax-zmin));

    }

    void FrameNode::getBoundingBox( float & minX, float & minY, float & minZ,
                                    float & maxX, float & maxY, float & maxZ)
    {
      //    //std::cerr<<"FrameNode::getBoundingBox"<<std::endl;

      if (x3dTransformNode)
      {
        // Fit the FrameNode bounding box to all the bounded chilren of FrameNode::x3dTransform, save this FrameNode
        bool boundedChild = false;
        if(x3dTransformNode->getChildList().size())
        {
          MFNode childList = x3dTransformNode->getChildList();
          for(MFNode::iterator it =  childList.begin() ; it !=  childList.end() ; ++it)
          {
            X3DBoundedObject * BO = dynamic_cast<X3DBoundedObject *>(*it);
            if((*it)!= this && BO)
            {
              SFVec3f sizeBBox = BO->getBBoxSize();
              if (size < sizeBBox.x)
                size = sizeBBox.x;
              if (size < sizeBBox.y)
                size = sizeBBox.y;
              if (size < sizeBBox.z)
                size = sizeBBox.z;
              boundedChild = true;
            }
          }
        }
        if (boundedChild)
          size *= swollen*0.5;
        else
          size = swollen;

        //qglviewer::Vec origine = qglviewer::Frame::position();
        qglviewer::Vec axis[3];
        axis[0] = qglviewer::Vec(size, 0.0, 0.0);
        axis[1] = qglviewer::Vec(0.0, size, 0.0);
        axis[2] = qglviewer::Vec(0.0, 0.0, size);

        minX = maxX = minY = maxY = minZ = maxZ =0.0;

        for (int i = 0; i<3; ++i)
        {
          if (minX > axis[i].x)
            minX = axis[i].x;
          if (maxX < axis[i].x)
            maxX = axis[i].x;

          if (minY > axis[i].y)
            minY = axis[i].y;
          if (maxY < axis[i].y)
            maxY = axis[i].y;

          if (minZ > axis[i].z)
            minZ = axis[i].z;
          if (maxZ < axis[i].z)
            maxZ = axis[i].z;
        }

        // To keep coherence between animal::Engine, X3D::X3DBoundedObject
        setBBoxCenter(SFVec3f((minX+maxX)/2.0, (minY+maxY)/2.0, (minZ+maxZ)/2.0));
        setBBoxSize(SFVec3f(maxX-minX, maxY-minY, maxZ-minZ));
      }
    }

    void FrameNode::updateFrame()
    {
      if (x3dTransformNode)
      {
        SFVec3f pos = x3dTransformNode->getCenter();
        qglviewer::Frame::setPosition(pos.x, pos.y, pos.z);
        SFVec3f trans = x3dTransformNode->getTranslation();
        qglviewer::Frame::setTranslation(trans.x, trans.y, trans.z);
        SFRotation rot = x3dTransformNode->getRotation();
        qglviewer::Frame::setRotation(qglviewer::Quaternion(qglviewer::Vec(rot.x, rot.y, rot.z), rot.angle));
      }
    }

    void FrameNode::updateTransform()
    {
      if (x3dTransformNode)
      {
        qglviewer::Vec pos = qglviewer::Frame::position();
        x3dTransformNode->setCenter(SFVec3f(pos[0], pos[1], pos[2]));
        qglviewer::Vec trans = qglviewer::Frame::translation();
        x3dTransformNode->setTranslation(SFVec3f(trans[0], trans[1], trans[2]));
        qglviewer::Vec axis = qglviewer::Frame::rotation().axis();
        float angle = qglviewer::Frame::rotation().angle();
        x3dTransformNode->setRotation(SFRotation(axis.x, axis.y, axis.z, angle));
      }
    }

    void FrameNode::updateFrameNode()
    {
      if (x3dTransformNode)
      {
        x3dTransformNode->setTranslation       (translation);
        x3dTransformNode->setRotation          (rotation);
        x3dTransformNode->setScale             (scale);
        x3dTransformNode->setScaleOrientation  (scaleOrientation);
        x3dTransformNode->setCenter            (center);
        updateFrame();
      }
    }

    void FrameNode::drawCone(float radius, float height, int nbSub)
    {
      qglviewer::Vec pos(radius, 0.0, 0.0);
      qglviewer::Vec prevNormal(1.0, 0.0, radius/height);
      qglviewer::Vec normal, newNormal;

      prevNormal.normalize();

      glBegin(GL_TRIANGLES);
      for (unsigned short i=1; i<=nbSub; ++i)
      {
        glNormal3fv(prevNormal.address());
        glVertex3fv(pos.address());

        normal.x = cos(2.0*M_PI*i/static_cast<float>(nbSub));
        normal.y = sin(2.0*M_PI*i/static_cast<float>(nbSub));
        normal.z = radius / height;

        pos.x = radius * normal.x;
        pos.y = radius * normal.y;

        normal.normalize();

        prevNormal = normal;
        glNormal3fv(prevNormal.address());
        glVertex3fv(pos.address());

        newNormal.x = prevNormal.x + normal.x;
        newNormal.y = prevNormal.y + normal.y;
        newNormal.z = 4.0*radius/height;
        newNormal.normalize();

        glNormal3fv(newNormal.address());
        glVertex3f(0.0, 0.0, height);
      }
      glEnd();
    }

    void FrameNode::drawCylinder(float radius, float length, int nbSub)
    {
      float prevX=radius, prevY=0.0f;
      float nx=1.0f, ny=0.0f;

      glBegin(GL_QUAD_STRIP);
      for (unsigned short i=1; i<=nbSub; ++i)
      {
        glNormal3f(nx, ny, 0.0);
        glVertex3f(prevX , prevY , length);
        glNormal3f(nx, ny, 0.0);
        glVertex3f(prevX , prevY , 0.0);

        nx = cos(2.0*M_PI*i/static_cast<float>(nbSub));
        ny = sin(2.0*M_PI*i/static_cast<float>(nbSub));

        prevX = radius * nx;
        prevY = radius * ny;

        glNormal3f(nx, ny, 0.0);
        glVertex3f(prevX , prevY , length);
        glNormal3f(nx, ny, 0.0);
        glVertex3f(prevX , prevY , 0.0);
      }
      glEnd();
    }

  }//X3D
}//X3DTK


void X3DTK::X3D::FrameNode::declareOutputs( X3D_X3DNodeList& list)
{
  list.push_back(x3dTransformNode);
}

---