view.C

/*
 * This file is part of the "Archon" framework.
 * (http://files3d.sourceforge.net)
 *
 * Copyright © 2002 by Kristian Spangsege and Brian Kristiansen.
 *
 * Permission to use, copy, modify, and distribute this software and
 * its documentation under the terms of the GNU General Public License is
 * hereby granted. No representations are made about the suitability of
 * this software for any purpose. It is provided "as is" without express
 * or implied warranty. See the GNU General Public License
 * (http://www.gnu.org/copyleft/gpl.html) for more details.
 *
 * The characters in this file are ISO8859-1 encoded.
 *
 * The documentation in this file is in "Doxygen" style
 * (http://www.doxygen.org).
 */

#include <math.h>
#include <typeinfo>
#include <iostream>
#include <map>

#include <GL/gl.h>
#include <GL/glu.h>

#include <archon/util/image.H>
#include <archon/util/random.H>

#include <archon/x3d/server/field_type.H>
#include <archon/x3d/server/load.H>
#include <archon/x3d/server/server.H>
#include <archon/x3d/server/view.H>

using namespace std;

namespace Archon
{
  using namespace Math;

  namespace X3D
  {
    Viewer::Viewer(Ref<Server> server,
                   int resolutionX, int resolutionY,
                   bool useMipmapedTextures,
                   string initialViewpointName,
                   const CoordSystem3x3 &viewCoordSystem,
                   double fieldOfView,
                   double depthOfRotation,
                   const Vector4 &backgroundColor,
                   int subdivisionX, int subdivisionY,
                   bool headLight,
                   bool showLightSources,
                   bool showNormals,
                   bool textAsQuadsMode,
                   bool wireframeMode,
                   bool enableTexture):
      server(server),
      resolutionX(resolutionX), resolutionY(resolutionY),
      aspectRatio(double(resolutionX)/resolutionY),
      nearClippingDist(1), farClippingDist(2000),
      useMipmapedTextures(useMipmapedTextures),
      viewCoordSystem(viewCoordSystem),
      fieldOfView(fieldOfView),
      depthOfRotation(depthOfRotation),
      renderConfig(subdivisionX, subdivisionY, showNormals, depthOfRotation/10, wireframeMode, textAsQuadsMode),
      headLight(headLight),
      showLightSources(showLightSources),
      disregardSensors(false),
      enableTexture(enableTexture),
      separateSpecularColorMode(false),
      lightModelLocalViewerMode(false),
      numberOfEnabledLights(0),
      updateShapeCacheDuringNextFrame(false),
      anyActiveDragSensors(false),
      pointingDevicePosition(0, 0),
      pointingDevicePositionChangedSinceLastFrame(false),
      pointingDeviceActive(false),
      pointingDeviceLastActive(false)
    {
      GLint param;
      glGetIntegerv(GL_MAX_LIGHTS, &param);
      maxLights = param;

      glViewport(0, 0, resolutionX, resolutionY);

      glClearColor(backgroundColor[0], backgroundColor[1],
                   backgroundColor[2], backgroundColor[3]);
      glDepthFunc(GL_LESS);
      glEnable(GL_DEPTH_TEST);                    

      // Disable all light sources
      for(unsigned i=0; i<maxLights; ++i) glDisable(GL_LIGHT0+i);

      if(server->getRootScene())
      {
        // Bind to the specified viewpoint
        if(!initialViewpointName.empty())
        {
          if(!bindViewpoint(initialViewpointName))
            server->getLogger()->log("WARNING: No such viewpoint '" +
                                     initialViewpointName + "'");
        }

        // Bind to the first viewpoint if any
        if(!boundViewpoint)
          boundViewpoint =
            findBoundViewpoint_group(server->getRootScene()->
                                     getRootGroup().get());
      }
    }

    bool Viewer::bindViewpoint(string name)
    {
      if(!server->getRootScene())
        ARCHON_THROW1(InternalException,
                      "Viewer::bindViewpoint: No root scene");

      Ref<NodeBase> n = server->getRootScene()->lookupNode(name);
      if(Viewpoint *v = dynamic_cast<Viewpoint *>(n.get()))
      {
        boundViewpoint = v;
        return true;
      }
      return false;
    }

    void Viewer::setupViewpoint()
    {
      if(boundViewpoint)
      {
        stack<const Transform *> transformPath;
        if(!server->getRootSceneNoLock())
          ARCHON_THROW1(InternalException,
                        "Viewer::setupViewpoint: No root scene");
        GroupingNode *g = server->getRootSceneNoLock()->getRootGroupNoLock().get();
        if(findBoundViewpoint_group(g, &transformPath))
        {
          viewCoordSystem = CoordSystem3x3::identity();
          while(!transformPath.empty())
          {
            const Transform *t = transformPath.top();
            transformPath.pop();
            viewCoordSystem.translate(t->getTranslation());
            viewCoordSystem.translate(t->getCenter());
            viewCoordSystem.basis.rotate(t->getRotation());
            viewCoordSystem.basis.rotate(t->getScaleOrientation());
            viewCoordSystem.basis.scale(t->getScale());
            viewCoordSystem.basis.rotate(-t->getScaleOrientation());
            viewCoordSystem.translate(-t->getCenter());
          }
          viewCoordSystem.translate(boundViewpoint->getPosition());
          viewCoordSystem.basis.rotate(boundViewpoint->getOrientation());

          fieldOfView = boundViewpoint->getFieldOfView();

          depthOfRotation = dist(boundViewpoint->getPosition(),
                                 boundViewpoint->getCenterOfRotation());
        }
      }

      const double viewPlaneRadius = nearClippingDist*tan(fieldOfView/2);
      if(aspectRatio > 1)
      {
        viewPlane[0] = viewPlaneRadius * aspectRatio;
        viewPlane[1] = viewPlaneRadius;
      }
      else
      {
        viewPlane[0] = viewPlaneRadius;
        viewPlane[1] = viewPlaneRadius / aspectRatio;
      }
      glMatrixMode(GL_PROJECTION);
      glLoadIdentity();
      glFrustum(-viewPlane[0], viewPlane[0], -viewPlane[1], viewPlane[1],
                nearClippingDist, farClippingDist);
      glMatrixMode(GL_MODELVIEW);

      CoordSystem3x3 invViewCoordSystem;
      invViewCoordSystem.setInverseOf(viewCoordSystem);
      GLdouble m[16];
      invViewCoordSystem.setOpenGLMatrix(m);
      glLoadMatrixd(m);
    }

    Viewpoint *Viewer::findBoundViewpoint_child(ChildNode *c,
                                                stack<const Transform *> *transformPath)
    {
      if(Viewpoint *v = dynamic_cast<Viewpoint *>(c))
      {
        if(!boundViewpoint ||
           boundViewpoint.get() == v) return v;
        return 0;
      }

      if(GroupingNode *g =
         dynamic_cast<GroupingNode *>(c))
      {
        if(Viewpoint *v = findBoundViewpoint_group(g, transformPath))
        {
          if(transformPath)
            if(Transform *t = dynamic_cast<Transform *>(g))
              transformPath->push(t);
          return v;
        }
        return 0;
      }

      return 0;
    }

    Viewpoint *Viewer::findBoundViewpoint_group(const GroupingNode *g,
                                                stack<const Transform *> *transformPath)
    {
      GroupingNode::const_iterator c=g->begin();

      if(const Switch *s = dynamic_cast<const Switch *>(g))
      {
        int i = s->getWhichChoise();
        if(i<0) return 0;
        c += i;
        if(c >= g->end()) return 0;
        return findBoundViewpoint_child(c->get(), transformPath);
      }

      while(c!=g->end())
      {
        if(Viewpoint *v = findBoundViewpoint_child(c->get(), transformPath))
          return v;
        ++c;
      }

      return 0;
    }


    void Viewer::calculateBillboardRotation(const Billboard *b, Rotation3 &r)
    {
      double m[16];
      glGetDoublev(GL_MODELVIEW_MATRIX, m);
      CoordSystem3x3 modelview(m);
      CoordSystem3x3 invModelview;
      invModelview.setInverseOf(modelview);

      Vector3 n = b->getAxisOfRotation();
      Vector3 e = invModelview.origin; // Direction towards eye in local coordinate system
      if(n == Vector3::zero())
      {
        // viewer-alignment

        // First rotate on plane of eye and z-axis
        Vector3 axis1;
        double k = e[0]*e[0] + e[1]*e[1]; // <1
        double ca1 = e[2]/sqrt(k + e[2]*e[2]); // >0 (e[2])
        if(k == 0)
        {
          // Line of sight is parallel with z-axis
          axis1.set(0, 1, 0);
        }
        else
        {
          k = sqrt(k); // <1
          axis1.set(-e[1]/k, e[0]/k, 0); // 0, 1, 0
        }

        // Then rotate about line of sight to align y-axis with viewers up-direction
        Vector3 y = e;
        y *= invModelview.basis.y;
        y *= e;
        k = y.squareSum();
        Vector3 axis2;
        double ca2;
        if(k == 0)
        {
          axis2.set(0, 1, 0);
          ca2 = 0; // We might want to choose a more reasonable rotation in this special case
        }
        else
        {
          y /= sqrt(k);
          k = (1 - ca1) * axis1[1]; // <1 (1-e[2])
          axis2.set(k * axis1[0],
                    k * axis1[1] + ca1,
                    axis1[0] * sqrt(1 - ca1 * ca1));
          ca2 = dot(axis2, y);
          axis2 *= y;
          axis2.normalize();
        }

        // Combine the two rotations through the use of quaternions
        Quaternion q1, q2;
        q1.setRotation(axis1, ca1);
        q2.setRotation(axis2, ca2);
        q2 *= q1;
        q2.getRotation(r);
        return;
      }

      e *= n;
      double l1 = e.length();
      if(l1 == 0)
      {
        // The axis of rotation is coincident with the direction
        // towards the eye. In this case every rotation angle is as
        // good as any other.
        r.axis = b->getAxisOfRotation();
        r.angle = 0;
        return;
      }
      n *= Vector3(0, 0, -1);
      double l2 = n.length();
      if(l2 == 0)
      {
        // The axis of rotation is coincident with the direction
        // defining the front of the object. In this case every
        // rotation angle is as good as any other.
        r.axis = b->getAxisOfRotation();
        r.angle = 0;
        return;
      }
      double p = dot(e, n) / l1 / l2;
      if(p == 1)
      {
        // We already face the front as much as possible.
        r.axis = b->getAxisOfRotation();
        r.angle = 0;
        return;
      }
      if(p == -1)
      {
        // We face the back as much as possible.
        r.axis = b->getAxisOfRotation();
        r.angle = M_PI;
        return;
      }

      n *= e;
      n.normalize();

      r.axis = n;
      r.angle = acos(p);
    }


    void Viewer::setupLight(bool headLight, bool showLightSources)
    {
      int nextLight = 0;

      if(showLightSources)
      {
        glPointSize(8);
        glEnable(GL_POINT_SMOOTH);
        glDisable(GL_LIGHTING);
        glDisable(GL_TEXTURE_2D);
      }

      if(!server->getRootSceneNoLock())
        ARCHON_THROW1(InternalException,
                      "Viewer::setupLight: No root scene");
      GroupingNode *g = server->getRootSceneNoLock()->getRootGroupNoLock().get();
      lightGroupingNode(g, nextLight, showLightSources);

      if(headLight)
      {
        int i = GL_LIGHT0 + nextLight++;

        GLfloat v[4];
        v[3] = 1;

        v[0] = 0.2;
        v[1] = 0.2;
        v[2] = 0.2;
        glLightfv(i, GL_AMBIENT, v);

        v[0] = 0.8;
        v[1] = 0.8;
        v[2] = 0.8;
        glLightfv(i, GL_DIFFUSE, v);

        v[0] = 0.8;
        v[1] = 0.8;
        v[2] = 0.8;
        glLightfv(i, GL_SPECULAR, v);

        v[0] = viewCoordSystem.origin[0];
        v[1] = viewCoordSystem.origin[1];
        v[2] = viewCoordSystem.origin[2];
        glLightfv(i, GL_POSITION, v);

        glLightf(i, GL_SPOT_CUTOFF, 180);

        glLightf(i, GL_CONSTANT_ATTENUATION,  1);
        glLightf(i, GL_LINEAR_ATTENUATION,    0);
        glLightf(i, GL_QUADRATIC_ATTENUATION, 0);

        glEnable(i);
      }

      for(int i=nextLight; i<numberOfEnabledLights; ++i)
        glDisable(GL_LIGHT0+i);

      numberOfEnabledLights = nextLight;
    }

    void Viewer::lightPointLight(const PointLight *l, int &nextLight, bool show)
    {
      if(l->getOn())
      {
        int i = GL_LIGHT0 + nextLight++;

        GLfloat v[4];
        v[3] = 1;

        v[0] = l->getColor()[0] * l->getAmbientIntensity();
        v[1] = l->getColor()[1] * l->getAmbientIntensity();
        v[2] = l->getColor()[2] * l->getAmbientIntensity();
        glLightfv(i, GL_AMBIENT, v);

        v[0] = l->getColor()[0] * l->getIntensity();
        v[1] = l->getColor()[1] * l->getIntensity();
        v[2] = l->getColor()[2] * l->getIntensity();
        glLightfv(i, GL_DIFFUSE, v);
        glLightfv(i, GL_SPECULAR, v);

        v[0] = l->getLocation()[0];
        v[1] = l->getLocation()[1];
        v[2] = l->getLocation()[2];
        glLightfv(i, GL_POSITION, v);

        glLightf(i, GL_SPOT_CUTOFF, 180);

        glLightf(i, GL_CONSTANT_ATTENUATION,  l->getAttenuation()[0]);
        glLightf(i, GL_LINEAR_ATTENUATION,    l->getAttenuation()[1]);
        glLightf(i, GL_QUADRATIC_ATTENUATION, l->getAttenuation()[2]);

        glEnable(i);
      }

      if(show)
      {
        glColor3d(l->getColor()[0], l->getColor()[1], l->getColor()[2]);
        glBegin(GL_POINTS);
        glVertex3d(l->getLocation()[0], l->getLocation()[1], l->getLocation()[2]);
        glEnd();
      }
    }

    void Viewer::lightSpotLight(const SpotLight *l, int &nextLight, bool show)
    {
      if(l->getOn())
      {
        int i = GL_LIGHT0 + nextLight++;

        GLfloat v[4];
        v[3] = 1;

        v[0] = l->getColor()[0] * l->getAmbientIntensity();
        v[1] = l->getColor()[1] * l->getAmbientIntensity();
        v[2] = l->getColor()[2] * l->getAmbientIntensity();
        glLightfv(i, GL_AMBIENT, v);

        v[0] = l->getColor()[0] * l->getIntensity();
        v[1] = l->getColor()[1] * l->getIntensity();
        v[2] = l->getColor()[2] * l->getIntensity();
        glLightfv(i, GL_DIFFUSE, v);
        glLightfv(i, GL_SPECULAR, v);

        v[0] = l->getLocation()[0];
        v[1] = l->getLocation()[1];
        v[2] = l->getLocation()[2];
        glLightfv(i, GL_POSITION, v);

        v[0] = l->getDirection()[0];
        v[1] = l->getDirection()[1];
        v[2] = l->getDirection()[2];
        glLightfv(i, GL_SPOT_DIRECTION, v);

        const double threshold = 0.75;
        float spotExponent =
          l->getBeamWidth() >= l->getCutOffAngle() ? 0 :
          l->getBeamWidth() <= acos(pow(threshold, 1.0/128)) ? 128 :
          log(threshold)/log(cos(l->getBeamWidth()));
        glLightf(i, GL_SPOT_EXPONENT, spotExponent);

        glLightf(i, GL_SPOT_CUTOFF, l->getCutOffAngle()/M_PI*180);

        glLightf(i, GL_CONSTANT_ATTENUATION,  l->getAttenuation()[0]);
        glLightf(i, GL_LINEAR_ATTENUATION,    l->getAttenuation()[1]);
        glLightf(i, GL_QUADRATIC_ATTENUATION, l->getAttenuation()[2]);

        glEnable(i);
      }

      if(show)
      {
        glColor3d(l->getColor()[0], l->getColor()[1], l->getColor()[2]);
        glBegin(GL_POINTS);
        glVertex3d(l->getLocation()[0], l->getLocation()[1], l->getLocation()[2]);
        glEnd();
      }
    }

    void Viewer::lightDispatchLightNode(const LightNode *l, int &nextLight, bool show)
    {
      if(const PointLight *p = dynamic_cast<const PointLight *>(l))
        lightPointLight(p, nextLight, show);
      else if(const SpotLight *p = dynamic_cast<const SpotLight *>(l))
        lightSpotLight(p, nextLight, show);
    }

    void Viewer::lightTransform(const Transform *t, int &nextLight, bool show)
    {
      glPushMatrix();

      glTranslatef(t->getTranslation()[0],
                   t->getTranslation()[1],
                   t->getTranslation()[2]);
      glTranslatef(t->getCenter()[0],
                   t->getCenter()[1],
                   t->getCenter()[2]);
      glRotatef(t->getRotation().angle/M_PI*180,
                t->getRotation().axis[0],
                t->getRotation().axis[1],
                t->getRotation().axis[2]);
      glRotatef(t->getScaleOrientation().angle/M_PI*180,
                t->getScaleOrientation().axis[0],
                t->getScaleOrientation().axis[1],
                t->getScaleOrientation().axis[2]);
      glScalef(t->getScale()[0],
               t->getScale()[1],
               t->getScale()[2]);
      glRotatef(t->getScaleOrientation().angle/M_PI*180*-1,
                t->getScaleOrientation().axis[0],
                t->getScaleOrientation().axis[1],
                t->getScaleOrientation().axis[2]);
      glTranslatef(t->getCenter()[0]*-1,
                   t->getCenter()[1]*-1,
                   t->getCenter()[2]*-1);

      lightGroupingNode(t, nextLight, show);

      glPopMatrix();
    }

    void Viewer::lightBillboard(const Billboard *b, int &nextLight, bool show)
    {
      glPushMatrix();

      Rotation3 r;
      calculateBillboardRotation(b, r);
      glRotatef(r.angle/M_PI*180, r.axis[0], r.axis[1], r.axis[2]);

      lightGroupingNode(b, nextLight, show);

      glPopMatrix();
    }

    void Viewer::lightDispatchGroupingNode(const GroupingNode *g, int &nextLight, bool show)
    {
      if(const Transform *t = dynamic_cast<const Transform *>(g))
        lightTransform(t, nextLight, show);
      else if(const Billboard *b = dynamic_cast<const Billboard *>(g))
        lightBillboard(b, nextLight, show);
      else if(const Switch *s = dynamic_cast<const Switch *>(g))
        lightSwitch(s, nextLight, show);
      else lightGroupingNode(g, nextLight, show);
    }

    void Viewer::lightSwitch(const Switch *s, int &nextLight, bool show)
    {
      GroupingNode::const_iterator c=s->begin();
      int i = s->getWhichChoise();
      if(i < 0) return;
      c += i;
      if(c >= s->end()) return;
      if(const LightNode *l = dynamic_cast<const LightNode *>(c->get()))
        lightDispatchLightNode(l, nextLight, show);
      else if(const GroupingNode *g2 = dynamic_cast<const GroupingNode *>(c->get()))
        lightDispatchGroupingNode(g2, nextLight, show);
    }

    void Viewer::lightGroupingNode(const GroupingNode *g, int &nextLight, bool show)
    {
      GroupingNode::const_iterator c=g->begin();
      while(c!=g->end())
      {
        if(const LightNode *l = dynamic_cast<const LightNode *>(c->get()))
          lightDispatchLightNode(l, nextLight, show);
        else if(const GroupingNode *g2 = dynamic_cast<const GroupingNode *>(c->get()))
          lightDispatchGroupingNode(g2, nextLight, show);
        else if(const SubSceneNode *s = dynamic_cast<const SubSceneNode *>(c->get()))
        {
          Ref<SceneBase> d = s->getSubSceneNoLock();
          if(d)
          {
            Ref<Group> h = d->getRootGroupNoLock();
            if(h) lightGroupingNode(h.get(), nextLight, show);
          }
        }
        ++c;
      }
    }



    struct TexUsage
    {
      GLuint textureId;
      int useCount;

      TexUsage(): useCount(0) {}
    };

    static map<Loader::Contents::Id, TexUsage> texMap;

    struct Viewer::ShapeCache: public Shape::DrawCache
    {
      GLuint textureId;
      GLuint callListId;

      Shape *shape;
      GeometryNode *geometry;

      Time calllistStamp;

      const FieldBase *geometryField;

      Loader::Contents::Id contentsId;

      ShapeCache(Shape *s): shape(s), geometry(0)
      {
        geometryField = Shape::type->lookupField("geometry");
        if(!geometryField)
          ARCHON_THROW1(InternalException,
                        "Could not find Shape.geometry field");
      }

      static vector<ShapeCache *> &getDisposedShapeCaches()
      {
        static vector<ShapeCache *> disposedShapeCaches;
        return disposedShapeCaches;
      }

      static void cleanUp()
      {
        for(unsigned i=0; i<getDisposedShapeCaches().size(); ++i)
          delete getDisposedShapeCaches()[i];
        getDisposedShapeCaches().clear();
      }

      void dispose()
      {
        getDisposedShapeCaches().push_back(this);
      }

      bool updateTexture(const Viewer *viewer)
      {
        ImageTexture *imageTexture = 0;
        Ref<const Loader::ImageContents> imageContents;
        AppearanceNode *appearance = shape->getAppearance().get();
        if(appearance)
        {
          Appearance *a = dynamic_cast<Appearance *>(appearance);
          if(!a) ARCHON_THROW1(InternalException,
                               "'" + appearance->getType()->getName() +
                               "' is not supported yet");

          TextureNode *textureNode = a->getTexture().get();
          if(textureNode)
          {
            imageTexture = dynamic_cast<ImageTexture *>(textureNode);
            if(!imageTexture)
              ARCHON_THROW1(InternalException,
                            "'" + textureNode->getType()->getName() +
                            "' is not supported yet");

            Ref<const Loader::Contents> c = imageTexture->getContents();
            imageContents = dynamic_cast<const Loader::ImageContents *>(c.get());
            if(c && !imageContents)
              ARCHON_THROW1(InternalException,
                            "Viewer::ShapeCache::updateTexture: Got "
                            "non-image contents object");
          }
        }

        Loader::Contents::Id newContentsId;
        if(imageContents) newContentsId = imageContents->getId();

        if(newContentsId == contentsId) return false;

        // Remove old texture
        if(contentsId)
        {
          TexUsage &texUsage = texMap[contentsId];
          if(--texUsage.useCount == 0)
          {
            glDeleteTextures(1, &texUsage.textureId); // Ups - what if
                                                      // the new
                                                      // texture is
                                                      // the same
                                                      // texture?
            texMap.erase(contentsId);
          }
        }

        contentsId = newContentsId;

        if(!contentsId) return true;

        // Check for existing?
        TexUsage &texUsage = texMap[contentsId];
        if(texUsage.useCount++ == 0)
        {
          // Inserted (new URI)

          const Image *image = &imageContents->image;
          int colorMode;
          switch(image->getComponentSpecifier())
          {
          case Utilities::Image::components_l:    colorMode = GL_LUMINANCE;       break;
          case Utilities::Image::components_la:   colorMode = GL_LUMINANCE_ALPHA; break;
          case Utilities::Image::components_rgb:  colorMode = GL_RGB;             break;
          case Utilities::Image::components_rgba: colorMode = GL_RGBA;            break;
          default:
            ARCHON_THROW1(InternalException,
                          "Unsuported color components");
          }

          int componentType;
          switch(image->getBitsPerComponent())
          {
          case 8:  componentType = GL_UNSIGNED_BYTE;  break;
          case 16: componentType = GL_UNSIGNED_SHORT; break;
          default:
            ARCHON_THROW1(InternalException,
                          "Unsuported color component width");
          }

          glGenTextures(1, &textureId);
          texUsage.textureId = textureId;
          glBindTexture(GL_TEXTURE_2D, textureId);
          glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S,
                          imageTexture->getRepeatS() ? GL_REPEAT : GL_CLAMP);
          glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T,
                          imageTexture->getRepeatT() ? GL_REPEAT : GL_CLAMP);
          glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
          glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
                          viewer->useMipmapedTextures ?
                          GL_NEAREST_MIPMAP_NEAREST : GL_LINEAR);
          glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);

          if(viewer->useMipmapedTextures)
            gluBuild2DMipmaps(GL_TEXTURE_2D, colorMode, image->getWidth(),
                              image->getHeight(), colorMode, componentType,
                              image->getPixelBuffer());
          else glTexImage2D(GL_TEXTURE_2D, 0, colorMode, image->getWidth(),
                            image->getHeight(), 0, colorMode, componentType,
                            image->getPixelBuffer());
        }
        else
        {
          textureId = texUsage.textureId;
        }

        return true;
      }

      bool updateCalllist()
      {
        GeometryNode *g = shape->getGeometry().get();
        if(!geometry && g) callListId = glGenLists(1);
        if(geometry && !g) glDeleteLists(callListId, 1);
        geometry = g;
        return geometryField->changedSince(shape, calllistStamp);       
      }

      bool update(const Viewer *viewer)
      {
        bool u = updateTexture(viewer) | updateCalllist();

        if(u) calllistStamp = viewer->server->getNextTimeStamp();

        return u;
      }

      ~ShapeCache()
      {{
        if(geometry) glDeleteLists(callListId, 1);
        if(contentsId)
        {
          TexUsage &texUsage = texMap[contentsId];
          if(--texUsage.useCount == 0)
          {
            glDeleteTextures(1, &texUsage.textureId);
            texMap.erase(contentsId);
          }
        }
      }}
    };

    Shape *Viewer::drawShape(ShapeNode *shapeNode)
    {
      Shape *shape = dynamic_cast<Shape *>(shapeNode);
      if(!shape)
        ARCHON_THROW1(InternalException,
                      "'" + shapeNode->getType()->getName() +
                      "' is not supported yet");

      if(!shape->drawCache) shape->drawCache = new ShapeCache(shape);
      ShapeCache *cache = static_cast<ShapeCache *>(shape->drawCache);

      const bool update = cache->update(this) || updateShapeCacheDuringNextFrame;
      if(!cache->geometry) return 0;
 
      AppearanceNode *appearanceNode = shape->getAppearance().get();
      Appearance *a = dynamic_cast<Appearance *>(appearanceNode);
      if(appearanceNode && !a)
        ARCHON_THROW1(InternalException,
                      "'" + appearanceNode->getType()->getName() +
                      "' is not supported yet");

      TextureNode *textureNode = a ? a->getTexture().get() : 0;
      ImageTexture *imageTexture=0;
      if(textureNode)
        imageTexture = dynamic_cast<ImageTexture *>(textureNode);
      
      const TextureTransformNode *textureTransformNode =
        a ? a->getTextureTransform().get() : 0;
      const TextureTransform *t =
        dynamic_cast<const TextureTransform *>(textureTransformNode);
      if(textureTransformNode && !t)
        ARCHON_THROW1(InternalException,
                      "'" + textureTransformNode->getType()->getName() +
                      "' is not supported yet");

      const MaterialNode *materialNode = a ? a->getMaterial().get() : 0;
      const Material *material = dynamic_cast<const Material *>(materialNode);
      if(materialNode && !material)
        ARCHON_THROW1(InternalException,
                      "'" + materialNode->getType()->getName() +
                      "' is not supported yet");
      if(material)
      {
        // Lit object
        GLenum face = GL_FRONT_AND_BACK;
        GLfloat c[4];

        double alpha = 1 - material->getTransparency();
        c[3]=alpha;
        glEnable(GL_LIGHTING);

        c[0]=material->getDiffuseColor()[0];
        c[1]=material->getDiffuseColor()[1];
        c[2]=material->getDiffuseColor()[2];
        glMaterialfv(face, GL_DIFFUSE, c);

        c[0] *= material->getAmbientIntensity();
        c[1] *= material->getAmbientIntensity();
        c[2] *= material->getAmbientIntensity();
        glMaterialfv(face, GL_AMBIENT, c);

        c[0] = material->getSpecularColor()[0];
        c[1] = material->getSpecularColor()[1];
        c[2] = material->getSpecularColor()[2];
        glMaterialfv(face, GL_SPECULAR, c);

        glMaterialf(face, GL_SHININESS, material->getShininess()*128);

        c[0] = material->getEmissiveColor()[0];
        c[1] = material->getEmissiveColor()[1];
        c[2] = material->getEmissiveColor()[2];
        glMaterialfv(face, GL_EMISSION, c);

        glColor3d(material->getDiffuseColor()[0],
                  material->getDiffuseColor()[1],
                  material->getDiffuseColor()[2]);
      }
      else
      {
        // Unlit object
        glDisable(GL_LIGHTING);
        glColor3d(1,1,1);
      }

      const bool texture = cache->contentsId;

      bool texStack = false;

      if(texture && enableTexture && !renderConfig.wireframeMode)
      {
        if(t)
        {
          glMatrixMode(GL_TEXTURE);
          glPushMatrix();
        
          //glLoadIdentity();
          glTranslatef(t->getCenter()[0],
                       t->getCenter()[1],
                       0);
          glScalef(t->getScale()[0],
                   t->getScale()[1],
                   1);
          glRotatef(t->getRotation()/M_PI*180,
                    0, 0, 1);
          glTranslatef(t->getCenter()[0]*-1,
                       t->getCenter()[1]*-1,
                       0);
          glTranslatef(t->getTranslation()[0],
                       t->getTranslation()[1],
                       0);

          glMatrixMode(GL_MODELVIEW);

          texStack = true;
        }

        glEnable(GL_TEXTURE_2D);
        glBindTexture(GL_TEXTURE_2D, cache->textureId);
        if(imageTexture)
        {
          glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, imageTexture->getRepeatS() ? GL_REPEAT : GL_CLAMP);
          glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, imageTexture->getRepeatT() ? GL_REPEAT : GL_CLAMP);
        }
      }
      else glDisable(GL_TEXTURE_2D);

      GeometryNode *g = cache->geometry;
      if(!update) glCallList(cache->callListId);
      else if(g)
      {
        glNewList(cache->callListId, GL_COMPILE_AND_EXECUTE);
        g->render(texture, shape, &renderConfig);
        glEndList();
      }

      if(texStack)
      {
        glMatrixMode(GL_TEXTURE);
        glPopMatrix();
        glMatrixMode(GL_MODELVIEW);
      }

      return g ? shape : 0;
    }

    void Viewer::drawTransform(Transform *t, bool sensor)
    {
      glPushMatrix();

      glTranslatef(t->getTranslation()[0],
                   t->getTranslation()[1],
                   t->getTranslation()[2]);
      glTranslatef(t->getCenter()[0],
                   t->getCenter()[1],
                   t->getCenter()[2]);
      glRotatef(t->getRotation().angle/M_PI*180,
                t->getRotation().axis[0],
                t->getRotation().axis[1],
                t->getRotation().axis[2]);
      glRotatef(t->getScaleOrientation().angle/M_PI*180,
                t->getScaleOrientation().axis[0],
                t->getScaleOrientation().axis[1],
                t->getScaleOrientation().axis[2]);
      glScalef(t->getScale()[0],
               t->getScale()[1],
               t->getScale()[2]);
      glRotatef(t->getScaleOrientation().angle/M_PI*180*-1,
                t->getScaleOrientation().axis[0],
                t->getScaleOrientation().axis[1],
                t->getScaleOrientation().axis[2]);
      glTranslatef(t->getCenter()[0]*-1,
                   t->getCenter()[1]*-1,
                   t->getCenter()[2]*-1);

      drawGroupingNode(t, sensor);

      glPopMatrix();
    }

    void Viewer::drawBillboard(Billboard *b, bool sensor)
    {
      glPushMatrix();

      Rotation3 r;
      calculateBillboardRotation(b, r);
      glRotatef(r.angle/M_PI*180, r.axis[0], r.axis[1], r.axis[2]);

      drawGroupingNode(b, sensor, &r);

      glPopMatrix();
    }

    void Viewer::drawSubSceneNode(SubSceneNode *s, bool sensor)
    {
      Ref<SceneBase> d = s->getSubSceneNoLock();
      if(!d) return;

      Ref<Group> h = d->getRootGroupNoLock();
      if(!h) return;

      dispatchGroupingNode(h.get(), sensor/* || selectionMode == selectApplications*/);
    }

    void Viewer::dispatchGroupingNode(GroupingNode *g, bool sensor)
    {
      if(Transform *t = dynamic_cast<Transform *>(g))
        drawTransform(t, sensor);
      else if(Billboard *b = dynamic_cast<Billboard *>(g))
        drawBillboard(b, sensor);
      else drawGroupingNode(g, sensor);
    }

    void Viewer::drawGroupingNode(GroupingNode *g, bool sensor, const Rotation3 *billboardRotation)
    {
      int numberOfDirectionalLights = 0;

      /*
       * Is this the group that introduces the first enabled sensors
       * for this branch?  If it is, we raise the flag 'sensor'.
       *
       * Also, setup all enabled directional light sources that are
       * direct children of this group.
       *
       * Note that if this is a Switch node then neither pointing
       * device sensors nor directional lights could have any
       * effect. This is because they affect only their siblings and
       * the children of their siblings, but since this is a Switch
       * node then at most one child can be active at one point in
       * time. Thus, there can be no siblings.
       */
      if(!dynamic_cast<const Switch *>(g))
      {
        GroupingNode::const_iterator c=g->begin();
        while(c!=g->end())
        {
          if(const PointingDeviceSensorNode *s =
             dynamic_cast<const PointingDeviceSensorNode *>(c->get()))
          {
            if(tracePointingRay/* && selectionMode == selectSensors*/ &&
               !sensor && s->getEnabled()) sensor = true;
          }
          else if(const DirectionalLight *l =
                  dynamic_cast<const DirectionalLight *>(c->get()))
          {
            if(l->getOn())
            {
              ++numberOfDirectionalLights;
              int i = GL_LIGHT0 + numberOfEnabledLights++;

              GLfloat v[4];
              v[3] = 1;

              v[0] = l->getColor()[0] * l->getAmbientIntensity();
              v[1] = l->getColor()[1] * l->getAmbientIntensity();
              v[2] = l->getColor()[2] * l->getAmbientIntensity();
              glLightfv(i, GL_AMBIENT, v);

              v[0] = l->getColor()[0] * l->getIntensity();
              v[1] = l->getColor()[1] * l->getIntensity();
              v[2] = l->getColor()[2] * l->getIntensity();
              glLightfv(i, GL_DIFFUSE, v);
              glLightfv(i, GL_SPECULAR, v);

              v[0] = -l->getDirection()[0];
              v[1] = -l->getDirection()[1];
              v[2] = -l->getDirection()[2];
              v[3] = 0; // Push the position to infinity
              glLightfv(i, GL_POSITION, v);

              glLightf(i, GL_SPOT_CUTOFF, 180);

              glEnable(i);
            }
          }

          ++c;
        }
      }

      /*
       * If we are detecting pointing ray collisions during this
       * frame, then all Shape nodes that are immediate children of
       * this GroupingNode are added to this list. These are the Shape
       * nodes that need to be tested for intersection with the
       * pointing ray.
       */
      vector<Shape *> shapes;

      // Recurse into childs of this group
      GroupingNode::const_iterator c=g->begin();
      ++level;
      if(Switch *s = dynamic_cast<Switch *>(g))
      {
        int i = s->getWhichChoise();
        if(i>=0)
        {
          c += i;
          if(c < g->end())
          {
            if(ShapeNode *s = dynamic_cast<ShapeNode *>(c->get()))
            {
              Shape *s2 = drawShape(s);
              if(tracePointingRay && s2) shapes.push_back(s2);
            }
            else if(SubSceneNode *s = dynamic_cast<SubSceneNode *>(c->get()))
              drawSubSceneNode(s, sensor);
            else if(GroupingNode *g2 = dynamic_cast<GroupingNode *>(c->get()))
              dispatchGroupingNode(g2, sensor);
          }
        }
      }
      else while(c!=g->end())
      {
        if(ShapeNode *s = dynamic_cast<ShapeNode *>(c->get()))
        {
          Shape *s2 = drawShape(s);
          if(tracePointingRay && s2) shapes.push_back(s2);
        }
        else if(SubSceneNode *s = dynamic_cast<SubSceneNode *>(c->get()))
          drawSubSceneNode(s, sensor);
        else if(GroupingNode *g2 = dynamic_cast<GroupingNode *>(c->get()))
          dispatchGroupingNode(g2, sensor);

        ++c;
      }
      --level;

      // Turn off directional light sources belonging to this group
      while(numberOfDirectionalLights--)
        glDisable(GL_LIGHT0 + --numberOfEnabledLights);

      if(!shapes.empty())
      {
        // Fetch and invert current model view matrix
        double m[16];
        glGetDoublev(GL_MODELVIEW_MATRIX, m);
        CoordSystem3x3 modelview(m);
        CoordSystem3x3 invModelview;
        invModelview.setInverseOf(modelview);

        // Map pointing ray into local coordinates
        Math::Ray3 localRay;
        localRay.direction = pointingRay;
        invModelview.basis.map(localRay.direction);
        localRay.origin = localRay.direction;
        localRay.origin += invModelview.origin;

        // Ray collision detection with extracted shapes
        bool anyHits = false;
        for(unsigned i=0; i<shapes.size(); ++i)
        {
          double dist;
          Shape *shape = shapes[i];
          int where = shape->getGeometry()->intersect(localRay, dist);
          if(where && (dist < hit.distance || hit.distance < 0))
          {
            hit.distance = dist;
            if(sensor)
            {
              hit.node = shape;
              hit.where = where;
            }
            anyHits = true;
          }
        }

        if(anyHits)
        {
          if(sensor)
          {
            hit.localRay = localRay;
            hitGroupThread.clear();
            hitGroupThreadBillboardRotations.clear();
            hitGroupThreadLowerLevel = level+1;
          }
          else hit.node = 0;
        }
      }

      if(hit.node && level < hitGroupThreadLowerLevel)
      {
        hitGroupThread.push_back(g);
        if(billboardRotation) hitGroupThreadBillboardRotations.push_back(*billboardRotation);
        --hitGroupThreadLowerLevel;
      }
    }

    void Viewer::resetViewpoint(string n, const CoordSystem3x3 &s)
    {
      if(!server->getRootScene())
        ARCHON_THROW1(InternalException,
                      "Viewer::resetViewpoint: No root scene");

      // Attempt to bind to the specified viewpoint
      if(!n.empty()) bindViewpoint(n);

      // Otherwise bind to the first viewpoint if any
      if(!boundViewpoint)
        boundViewpoint =
          findBoundViewpoint_group(server->getRootScene()->
                                   getRootGroup().get());

      // Otherwise use the default view point
      if(!boundViewpoint) viewCoordSystem = s;
    }


    void Viewer::setPointingDeviceActive(bool m)
    {
      pointingDeviceActive = m;
    }

    void Viewer::setInitialPointingDevicePosition2D(Vector2 p)
    {
      pointingDevicePosition = p;
    }

    void Viewer::setPointingDevicePosition2D(Vector2 p)
    {
      pointingDevicePosition = p;
      pointingDevicePositionChangedSinceLastFrame = true;
    }

    void Viewer::renderFrame()
    {
      // Considder pointing device activation and deactivation
      bool activate = false;
      bool deactivate = false;
      if(pointingDeviceActive && !disregardSensors)
      {
        if(!pointingDeviceLastActive)
        {
          activate = true;
          pointingDeviceLastActive = true;
        }
      }
      else if(pointingDeviceLastActive)
      {
        deactivate = true;
        pointingDeviceLastActive = false;
      }

      if(pointingDevicePositionChangedSinceLastFrame && !disregardSensors || activate)
      {
        pointingRay[0] = viewPlane[0] * ( 2 * pointingDevicePosition[0] / resolutionX - 1);
        pointingRay[1] = viewPlane[1] * (-2 * pointingDevicePosition[1] / resolutionY + 1);
        pointingRay[2] = -nearClippingDist;

        tracePointingRay = true;
      }
      else tracePointingRay = false;

      hit.node = 0;
      level = 0;
      hitGroupThread.clear();
      hitGroupThreadBillboardRotations.clear();
      hit.distance = -1; // Force first hit to be closer than "previous".

      glShadeModel(GL_SMOOTH);
      glColorMaterial(GL_FRONT_AND_BACK, GL_DIFFUSE);
      glEnable(GL_NORMALIZE);
      glPolygonMode(GL_FRONT_AND_BACK, renderConfig.wireframeMode ? GL_LINE : GL_FILL);
      glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL, separateSpecularColorMode ? GL_SEPARATE_SPECULAR_COLOR : GL_SINGLE_COLOR);
      glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, lightModelLocalViewerMode ? 1 : 0);

      Mutex::Lock lock(server->scenegraphMutex);

      // Process input events and generate new autonomous (time based)
      // events
      server->tick();

      /*
       * This must be done by the same thread that createss
       * ShapeCaches since in involves OpenGL commands.
       */
      ShapeCache::cleanUp();

      Scene *rootScene = server->getRootSceneNoLock().get();
      if(rootScene)
      {
        GroupingNode *rootGroup = rootScene->getRootGroupNoLock().get();
        if(rootGroup)
        {
          glMatrixMode(GL_PROJECTION);
          glLoadIdentity();
          glFrustum(-1, 1, -1, 1, 1, 1000-1);
          glMatrixMode(GL_MODELVIEW);
          glLoadIdentity();
          glTranslated(0, 0, -10);

          setupViewpoint();

          setupLight(headLight, showLightSources);

          /*
           * Render the scene and on request 'tracePointingRay=true' trace
           * the pointing ray for intersection with sensor affected
           * geometry. Upon return 'hit.node!=0' will indicate that the
           * ray has hit a sensor affected shape node and a reference to
           * that node is stored in 'hit.node'. The rest of the fields of
           * 'hit' will be set to reflect that hit, and 'hitGroupThread'
           * will contain the path given in grouping nodes starting with
           * the one imediately enclosing 'hit.node' to the root group of
           * the scene.
           */
          drawGroupingNode(rootGroup, false);
        }
      }

      // Handling PointingDeviceSensorNodes:
      //
      // We need to keep a set of references to
      // PointingDeviceSensorNodes whos isOver attribute has been set
      // to true. This list must be kept in the Viewer object, and we
      // need it to make sure that all those nodes get their isOver
      // attribute reset to false, even if they are removed from the
      // GroupingNode with isOver set to true. We call this list of
      // PointingDeviceSensorNodes the isOver set.
      //
      // For a given PointingDeviceSensorNode the isOver attribute
      // should be true when and only when the
      // PointingDeviceSensorNode is enabled and is in the current
      // isOver set.
      //
      // We should work with sets as opposed to lists of
      // PointingDeviceSensorNodes here to prevent sending isOver
      // events several times on the same node just because it is
      // included several times in the same GroupingNode.
      //
      // Set isOver to false for all enabled PointingDeviceSensorNodes
      // which was in the isOver set during the previous frame but
      // are not there now.
      //
      // Remember to set isOver to false when a
      // PointingDeviceSensorNode is disabled and has isOver set to
      // true. This must be dealt with during event handling.
      //
      // Set isOver to true for all enabled PointingDeviceSensorNodes
      // which are now in the isOver set but was not there during
      // thre previous frame.
      //
      // Calculate the mapping from the coordinate system of the
      // intersected geometry to the coordinate system of the sensor
      // group if one of the following is true:
      //
      //  - The isOver set contains at least one TouchSensor. We
      //    need to map the hit point and the hit normal
      //  - The isOver set contains at least one DragSensorNode and
      //    this is the first frame of the drag. We need to calculate
      //    the dimensions of the virtual geometry of the
      //    DragSensorNode, but only at the first frame of the drag.
      //
      // If the isOver set contains at least one TouchSensor, calculate
      // the inverse mapping of the one calculated above for mapping
      // hit-normals.
      //
      // ---------------------------------------------------------------
      // Fig. 1: The hitGroupThread layout (an example)
      //
      // Index:                0   1   2   3
      // Transformation:     - > - > - > - > -     > -
      // Coordinate system:  G       S       R       E
      //
      // Legend:
      // -: A coordinate system
      // >: A transformation (plain Groups are identity transformations)
      // G: The coordinate system of the indicated geometry
      // S: The coordinate system of the influenced sensors
      // R: The root coordinate system
      // E: Eye-space (ie. the current view point coordinate system)
      //
      // Note: Coordinate systems G, S and R may all be
      // coincident. That is, without any transformations/groups
      // between them.
      //
      // Note: The transformation at index 3 (in this case) is the
      // root group of the scene graph and is thus an identity
      // transformation, never the less it is always included in the
      // hitGroupThread.
      //
      // Note: The last transformation (without index) is the view point
      // transformation and is not included in the hitGroupThread.
      // ---------------------------------------------------------------
      //

      Time timeStamp = server->getNextTimeStamp();

      /*
       * Run down the thread of GroupingNodes from the intersected
       * geometry towards the root of the scene graph in search of the
       * first one holding at least one enabled
       * PointingDeviceSensorNode. In fig 1 this is index 2.
       */
      unsigned sensorIndex = 0;
      unsigned sensorIndexInBillboardRotations = 0; // Or number of billboards under sensor group
      if(hit.node)
      {
        while(sensorIndex < hitGroupThread.size())
        {
          const GroupingNode *g = hitGroupThread[sensorIndex];
          GroupingNode::const_iterator j=g->begin();
          while(j != g->end())
          {
            if(const PointingDeviceSensorNode *s =
               dynamic_cast<const PointingDeviceSensorNode *>(j->get()))
              if(s->getEnabled()) break;
            ++j;
          }
          if(j != g->end()) break;
          ++sensorIndex;
          if(dynamic_cast<const Billboard *>(g)) ++sensorIndexInBillboardRotations;
        }

        if(sensorIndex == hitGroupThread.size())
          ARCHON_THROW1(InternalException, "Could not find sensor group");
      }

      // Build new isOverSet and determine existance of touch and/or
      // drag sensors
      bool anyTouchSensors = false;
      bool anyDragSensors = false;
      set<Ref<PointingDeviceSensorNode> > newOverSet;
      if(hit.node)
      {
        Ref<const GroupingNode> g = hitGroupThread[sensorIndex];
        GroupingNode::const_iterator i=g.get()->begin();
        while(i!=g.get()->end())
        {
          if(PointingDeviceSensorNode *s =
             dynamic_cast<PointingDeviceSensorNode *>(const_cast<ChildNode *>(i->get())))
            if(s->getEnabled())
            {
              if(dynamic_cast<TouchSensor *>(s)) anyTouchSensors = true;
              if(dynamic_cast<DragSensorNode *>(s)) anyDragSensors = true;
              newOverSet.insert(s);
            }
          ++i;
        }
      }

      // Update the isOver set if the pointing ray was traced in this
      // frame (pointing device movement or activation)
      if(tracePointingRay)
      {
        // Set isOver to false for all enabled PointingDeviceSensorNodes
        // which was in the isOver set during the previous frame but
        // are not there now.
        {
          set<Ref<PointingDeviceSensorNode> >::iterator i = pointingDeviceOverSet.begin();
          while(i != pointingDeviceOverSet.end())
          {
            if(newOverSet.find(*i) == newOverSet.end())
            {
              PointingDeviceSensorNode *s = i->get();
              if(s->isOver)
              {
                s->isOver = false;
                Event e(new SimpleValue<bool>(SFBool::type, s->isOver), timeStamp);
                s->isOverChanged.cascadeEvent(&e);
              }
            }
            ++i;
          }
        }

        // Set isOver to true for all enabled PointingDeviceSensorNodes
        // which are now in the isOver set but was not there during
        // thre previous frame.
        if(hit.node)
        {
          set<Ref<PointingDeviceSensorNode> >::iterator i = newOverSet.begin();
          while(i != newOverSet.end())
          {
            if(pointingDeviceOverSet.find(*i) == pointingDeviceOverSet.end())
            {
              PointingDeviceSensorNode *s = i->get();
              if(!s->isOver)
              {
                s->isOver = true;
                Event e(new SimpleValue<bool>(SFBool::type, s->isOver), timeStamp);
                s->isOverChanged.cascadeEvent(&e);
              }
            }
            ++i;
          }
        }

        // Save the current isOver set for next frame
        pointingDeviceOverSet = newOverSet;
      }

      // Handle deactivation of sensors
      if(deactivate && !pointingDeviceActiveSet.empty())
      {
        set<Ref<PointingDeviceSensorNode> >::iterator i = pointingDeviceActiveSet.begin();
        while(i != pointingDeviceActiveSet.end())
        {
          PointingDeviceSensorNode *s = i->get();
          if(s->isActive)
          {
            s->isActive = false;
            Event e(new SimpleValue<bool>(SFBool::type, s->isActive), timeStamp);
            s->isActiveChanged.cascadeEvent(&e);
          }
          ++i;
        }

        // Set touchTime fields of the TouchSensors that are currently
        // also in the isOver set. And handle autoOffest for DragSensorNodes.
        i = pointingDeviceActiveSet.begin();
        while(i != pointingDeviceActiveSet.end())
        {
          PointingDeviceSensorNode *s = i->get();
          if(TouchSensorNode *t = dynamic_cast<TouchSensorNode *>(s))
          {
            if(pointingDeviceOverSet.find(*i) != pointingDeviceOverSet.end())
            {
              t->touchTime = timeStamp;
              Event e(new SimpleValue<Time>(SFTime::type, t->touchTime), timeStamp);
              t->touchTimeChanged.cascadeEvent(&e);
            }
          }
          else if(PlaneSensor *t = dynamic_cast<PlaneSensor *>(s))
          {
            if(t->autoOffset)
            {
              t->offset = t->translation;
              Event e(new SimpleValue<Vector3>(SFVec3f::type, t->offset), timeStamp);
              t->offsetChanged.cascadeEvent(&e);
            }
          }
          else if(SphereSensor *t = dynamic_cast<SphereSensor *>(s))
          {
            if(t->autoOffset)
            {
              t->offset = t->rotation;
              Event e(new SimpleValue<Rotation3>(SFVec3f::type, t->offset), timeStamp);
              t->offsetChanged.cascadeEvent(&e);
            }
          }
          else if(CylinderSensor *t = dynamic_cast<CylinderSensor *>(s))
          {
            if(t->autoOffset)
            {
              t->offset = t->rotation.angle;
              Event e(new SimpleValue<double>(SFVec3f::type, t->offset), timeStamp);
              t->offsetChanged.cascadeEvent(&e);
            }
          }

          ++i;
        }

        pointingDeviceActiveSet.clear();
        anyActiveDragSensors = false;
      }

      // Handle activation of sensors
      bool startDrag = activate && !pointingDeviceOverSet.empty();
      if(startDrag)
      {
        pointingDeviceActiveSet = pointingDeviceOverSet;
        anyActiveDragSensors = anyDragSensors;

        set<Ref<PointingDeviceSensorNode> >::iterator i = pointingDeviceActiveSet.begin();
        while(i != pointingDeviceActiveSet.end())
        {
          PointingDeviceSensorNode *s = i->get();
          if(!s->isActive)
          {
            s->isActive = true;
            Event e(new SimpleValue<bool>(SFBool::type, s->isActive), timeStamp);
            s->isActiveChanged.cascadeEvent(&e);
          }
          ++i;
        }
      }

      /*
       * These flags must be cleared at each invocation of this method
       * and after the actual rendering which is initiated by the call
       * to 'drawGroupingNode' above.
       */
      updateShapeCacheDuringNextFrame = false;
      pointingDevicePositionChangedSinceLastFrame = false;


      // Quit here if the pointing device position has not changed and
      // not been activated since the previous frame.
      if(!tracePointingRay) return;

      // An obvious optimization opportunity here is that we do not
      // need to calculate for example the hitNormal for the touch
      // sensor if no routes are attached to that field.
      Vector3 hitPoint;
      Vector3 hitNormal;
      Vector2 hitTexCoord;
      // Note that: hit.node == null ==> startDrag == false
      if(hit.node && anyTouchSensors || startDrag && anyDragSensors)
      {
        // Calculate the mapping from the coordinate system of the
        // intersected geometry to the coordinate system of the sensor
        // group. In fig. 1 this is the combination of transformations
        // 0 and 1.
        CoordSystem3x3 m = CoordSystem3x3::identity();
        for(unsigned i = sensorIndex, j = sensorIndexInBillboardRotations; i>0; --i)
        {
          const GroupingNode *g = hitGroupThread[i-1];

          if(const Transform *t = dynamic_cast<const Transform *>(g))
          {
            m.translate(t->getTranslation());
            m.translate(t->getCenter());
            m.basis.rotate(t->getRotation());
            m.basis.rotate(t->getScaleOrientation());
            m.basis.scale(t->getScale());
            m.basis.rotate(-t->getScaleOrientation());
            m.translate(-t->getCenter());
          }
          else if(dynamic_cast<const Billboard *>(g))
            m.basis.rotate(hitGroupThreadBillboardRotations[--j]);
        }

        // Determine the hit point in the coordinate system of the
        // intersected geometry.
        hitPoint = hit.localRay.direction;
        hitPoint *= hit.distance;
        hitPoint += hit.localRay.origin;

        if(anyTouchSensors)
        {
          // Calculate the hitNormal and the hitTexCoord
          hit.node->getGeometry()->getNormalAndTexCoord(hitPoint, hit.where, hit.node, &hitNormal, &hitTexCoord);

          /*
          // For debugging hitPoint and especially hitNormal
          glEnable(GL_COLOR_MATERIAL);
          glDisable(GL_TEXTURE_2D);
          glColor3d(1, 1, 1);
          glBegin(GL_LINES);
          glVertex3d(hitPoint[0], hitPoint[1], hitPoint[2]);
          glVertex3d(hitPoint[0]+hitNormal[0], hitPoint[1]+hitNormal[1], hitPoint[2]+hitNormal[2]);
          glEnd();
          */

          // When mapping normals we need to derive the "normal map"
          // from 'm'. m.basis is the "tangential map". The transpose
          // of the inverse of the tangential map is the normal map.
          Matrix3x3 invMap;
          invMap.setInverseOf(m.basis);
          hitNormal *= invMap; // Transposed mapping
          hitNormal.normalize();
        }

        // Map the hit point to the coordinate system of the sensors.
        m.map(hitPoint);
      }

      // If this is the first frame of a drag, we need to determine
      // the mapping from eye-space to the sensor coordinate system
      // and save it into the Viewer object for mapping pointing rays
      // for the following frames of the drag. In fig. 1 this is the
      // combination of transformations 2 and 3 and the view point
      // transformation.
      if(startDrag && anyDragSensors)
      {
        // We combine the transformations in reverse order to
        // eliminate a pair of matrix inversions. That is, we utilize
        // the rule that the inverse of a matrix product is the
        // product of the inverse matrices in reverse order.
        CoordSystem3x3 m = CoordSystem3x3::identity();
        for(unsigned i = sensorIndex, j = sensorIndexInBillboardRotations; i<hitGroupThread.size(); ++i)
        {
          const GroupingNode *g = hitGroupThread[i];

          if(const Transform *t = dynamic_cast<const Transform *>(g))
          {
            m.translate(t->getCenter());
            m.basis.rotate(t->getScaleOrientation());
            m.basis.invScale(t->getScale());
            m.basis.rotate(-t->getScaleOrientation());
            m.basis.rotate(-t->getRotation());
            m.translate(-t->getCenter());
            m.translate(-t->getTranslation());
          }
          else if(dynamic_cast<const Billboard *>(g))
            m.basis.rotate(-hitGroupThreadBillboardRotations[j++]);
        }

        m *= viewCoordSystem;

        eyeToSensorMap = m;

        // We need to save in the Viewer object the initial hit point
        // of a drag operation, for use in the remainder of the drag
        // operation.
        initialDragHitPoint = hitPoint;
      }

      // Map the pointing ray into the sensor coordinate system during
      // a drag.
      Ray3 sensorRay;
      if(anyActiveDragSensors)
      {
        // Note: The pointing ray is represented by a single vector
        // since its origin vector and direction vector are always
        // identical.
        sensorRay.direction = pointingRay;
        eyeToSensorMap.basis.map(sensorRay.direction);
        sensorRay.origin = sensorRay.direction;
        sensorRay.origin += eyeToSensorMap.origin;
      }

      // Calculate and send out TouchSensor tracking events
      {
        set<Ref<PointingDeviceSensorNode> >::iterator i = pointingDeviceOverSet.begin();
        while(i != pointingDeviceOverSet.end())
        {
          PointingDeviceSensorNode *s = i->get();
          if(TouchSensor *t = dynamic_cast<TouchSensor *>(s))
          {
            // hitPoint
            {
              t->hitPoint = hitPoint;
              Event e(new SimpleValue<Vector3>(SFVec3f::type, t->hitPoint), timeStamp);
              t->hitPointChanged.cascadeEvent(&e);
            }

            // hitNormal
            {
              t->hitNormal = hitNormal;
              Event e(new SimpleValue<Vector3>(SFVec3f::type, t->hitNormal), timeStamp);
              t->hitNormalChanged.cascadeEvent(&e);
            }

            // hitTexCoord
            {
              t->hitTexCoord = hitTexCoord;
              Event e(new SimpleValue<Vector2>(SFVec2f::type, t->hitTexCoord), timeStamp);
              t->hitTexCoordChanged.cascadeEvent(&e);
            }
          }
          ++i;
        }
      }

      // Calculate and send out DragSensor tracking events
      {
        set<Ref<PointingDeviceSensorNode> >::iterator i = pointingDeviceActiveSet.begin();
        while(i != pointingDeviceActiveSet.end())
        {
          PointingDeviceSensorNode *s = i->get();
          ++i;
          if(PlaneSensor *t = dynamic_cast<PlaneSensor *>(s))
          {
            Vector3 p;
            if(startDrag) p = initialDragHitPoint;
            else
            {
              // Calculate intersection with virtual plane
              double k = sensorRay.direction[2];
              if(k == 0) continue;
              k = (initialDragHitPoint[2] - sensorRay.origin[2]) / k;
              if(k <= 0) continue;
              p[0] = sensorRay.origin[0] + k * sensorRay.direction[0];
              p[1] = sensorRay.origin[1] + k * sensorRay.direction[1];
              p[2] = initialDragHitPoint[2];
            }

            // Send out tracking events
            {
              t->trackPoint = p;
              Event e(new SimpleValue<Vector3>(SFVec3f::type, t->trackPoint), timeStamp);
              t->trackPointChanged.cascadeEvent(&e);
            }

            p -= initialDragHitPoint;
            p += t->offset;

            // Clamp x-coordinate
            if(t->minPosition[0] <= t->maxPosition[0])
            {
              if(p[0] < t->minPosition[0]) p[0] = t->minPosition[0];
              else if(p[0] > t->maxPosition[0]) p[0] = t->maxPosition[0];
            }

            // Clamp y-coordinate
            if(t->minPosition[1] <= t->maxPosition[1])
            {
              if(p[1] < t->minPosition[1]) p[1] = t->minPosition[1];
              else if(p[1] > t->maxPosition[1]) p[1] = t->maxPosition[1];
            }

            {
              t->translation = p;
              Event e(new SimpleValue<Vector3>(SFVec3f::type, t->translation), timeStamp);
              t->translationChanged.cascadeEvent(&e);
            }
          }
          else if(SphereSensor *t = dynamic_cast<SphereSensor *>(s))
          {
            Vector3 p;
            if(startDrag)
            {
              p = initialDragHitPoint;
              virtualSphereSensor = Math::Sphere3(initialDragHitPoint.length());
            }
            else
            {
              // Calculate intersection with virtual sphere
              double dist;
              if(!Math::intersect(sensorRay, virtualSphereSensor, dist)) return;
              p = sensorRay.direction;
              p *= dist;
              p += sensorRay.origin;
            }

            // Send out tracking events
            {
              t->trackPoint = p;
              Event e(new SimpleValue<Vector3>(SFVec3f::type, t->trackPoint), timeStamp);
              t->trackPointChanged.cascadeEvent(&e);
            }

            {
              double ca = dot(p, initialDragHitPoint) /
                (virtualSphereSensor.radius*virtualSphereSensor.radius);
              if(ca >= 1) t->rotation = t->offset;
              else
              {
                p *= initialDragHitPoint;
                double s = p.squareSum();
                if(s==0) t->rotation = t->offset;
                else
                {
                  p /= sqrt(s); // Normalize
                  p.negate();

                  // Combine the two rotations through the use of quaternions
                  Quaternion q1, q2;
                  q1.setRotation(t->offset);
                  q2.setRotation(p, ca);
                  q2 *= q1;
                  q2.getRotation(t->rotation);
                }
              }

              Event e(new SimpleValue<Rotation3>(SFRotation::type, t->rotation), timeStamp);
              t->rotationChanged.cascadeEvent(&e);
            }
          }
          else if(CylinderSensor *t = dynamic_cast<CylinderSensor *>(s))
          {
            Vector3 p;
            if(startDrag)
            {
              p = initialDragHitPoint;

              // Determine wether this is a disc or cylinder rotation
              double a = acos(sensorRay.direction[1]/sensorRay.direction.length());
              if(a > M_PI/2) a = M_PI - a; // Get acute angle

              // Get a polar representation of initialDragHitPoint
              virtualCylinderSensorRadius = a < t->diskAngle ? -1 : Math::length(p[0], p[2]);
              virtualCylinderSensorAngle = Math::angle(p[0], -p[2]);
            }
            else if(virtualCylinderSensorRadius < 0)
            {
              // Calculate intersection with virtual disc
              double k = sensorRay.direction[1];
              if(k == 0) continue;
              k = (initialDragHitPoint[1] - sensorRay.origin[1]) / k;
              p[0] = sensorRay.origin[0] + k * sensorRay.direction[0];
              p[1] = initialDragHitPoint[1];
              p[2] = sensorRay.origin[2] + k * sensorRay.direction[2];
            }
            else
            {
              // Calculate intersection with virtual cylinder
              double dist;
              if(!Math::intersectCylinder(sensorRay, -1, virtualCylinderSensorRadius, dist)) return;
              p = sensorRay.direction;
              p *= dist;
              p += sensorRay.origin;
            }

            // Send out tracking events
            {
              t->trackPoint = p;
              Event e(new SimpleValue<Vector3>(SFVec3f::type, t->trackPoint), timeStamp);
              t->trackPointChanged.cascadeEvent(&e);
            }

            double a = Math::angle(p[0], -p[2]) - virtualCylinderSensorAngle;

            // Fix range of difference to [-pi;pi)
            if(a < -M_PI) a += 2*M_PI;
            else if(a >= M_PI) a -= 2*M_PI;

            a += t->offset;

            // Clamp effective angle
            if(t->minAngle <= t->maxAngle)
            {
              if(a < t->minAngle) a = t->minAngle;
              else if(a > t->maxAngle) a = t->maxAngle;
            }

            {
              t->rotation.angle = a;
              Event e(new SimpleValue<Rotation3>(SFRotation::type, t->rotation), timeStamp);
              t->rotationChanged.cascadeEvent(&e);
            }
          }
        }
      }
    }
  }
}

---