scene_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 <GL/gl.h>

#include <archon/math/vector.H>
#include <archon/util/time.H>
#include <archon/util/mutex.H>
#include <archon/util/window.H>
#include <archon/util/keyboard.H>
#include <archon/util/mouse.H>
#include <archon/util/color.H>
#include <archon/util/mutex.H>
#include <archon/util/text.H>

#include <archon/x3d/server/x3d.H>
#include <archon/x3d/server/server.H>

#include <archon/3dconsole/exception.H>
#include <archon/3dconsole/scene_view.H>

#include <unistd.h>

namespace Archon
{
  using namespace Math;
  using namespace Utilities;

  namespace Console3d
  {

    void get_scene(const X3D::Scene *,
                   vector<pair<Vector3, const X3D::LightNode *> > &);

    class WindowQuitHandler: public Window::WindowHandler
    {
      bool &quitFlag;

    public:
      WindowQuitHandler(bool &quitFlag): quitFlag(quitFlag) {}

      void quit()
      {
        quitFlag = true;
      }
    };

    void drawDepthMarker(double depth)
    {
      const double d = 20;

      glDisable(GL_POINT_SMOOTH);
      glDisable(GL_LINE_SMOOTH);
      glPointSize(5);
      glLineWidth(1);
      glColor3f(1, 1, 1);

      glBegin(GL_POINTS);
      glVertex3f(0, 0, -depth);
      glEnd();

      for(int i=1; i<10; ++i)
      {
        glBegin(GL_LINE_LOOP);

        glVertex3f(+d*i, -d*i, -depth);
        glVertex3f(+d*i, +d*i, -depth);
        glVertex3f(-d*i, +d*i, -depth);
        glVertex3f(-d*i, -d*i, -depth);

        glEnd();
      }
    }

    static const char *defaultMouseCursorData[] =
    {
      //width height num_colors chars_per_pixel
      "    32    32        3            1",
      //colors
      "X c #000000",
      ". c #ffffff",
      "  c None",
      //pixels
      "                                ",
      "                                ",
      "                                ",
      "                                ",
      "                                ",
      "                                ",
      "        XX             XX       ",
      "       X..X           X..X      ",
      "       X...X         X...X      ",
      "        X...X       X...X       ",
      "         X...X     X...X        ",
      "          X...X   X...X         ",
      "           X...X X...X          ",
      "            X..X X..X           ",
      "             XX   XX            ",
      "                                ",
      "             XX   XX            ",
      "            X..X X..X           ",
      "           X...X X...X          ",
      "          X...X   X...X         ",
      "         X...X     X...X        ",
      "        X...X       X...X       ",
      "       X...X         X...X      ",
      "       X..X           X..X      ",
      "        XX             XX       ",
      "                                ",
      "                                ",
      "                                ",
      "                                ",
      "                                ",
      "                                ",
      "                                ",
      "16,15"
    };

    static const char *sensorMouseCursorData[] =
    {
      //width height num_colors chars_per_pixel
      "    32    32        3            1",
      //colors
      "X c #000000",
      ". c #ffffff",
      "  c None",
      //pixels
      "                                ",
      "                                ",
      "                                ",
      "                                ",
      "                                ",
      "              XXXXX             ",
      "            XX.....XX           ",
      "          XX..XXXXX..XX         ",
      "         X..X      XX..X        ",
      "        X..X         X..X       ",
      "        X.X           X.X       ",
      "       X.X             X.X      ",
      "       X.X             X.X      ",
      "      X.X       X       X.X     ",
      "      X.X      X.X      X.X     ",
      "      X.X     X...X     X.X     ",
      "      X.X      X.X      X.X     ",
      "      X.X       X       X.X     ",
      "       X.X             X.X      ",
      "       X.X             X.X      ",
      "        X.X           X.X       ",
      "        X..X         X..X       ",
      "         X..XX     XX..X        ",
      "          XX..XXXXX..XX         ",
      "            XX.....XX           ",
      "              XXXXX             ",
      "                                ",
      "                                ",
      "                                ",
      "                                ",
      "                                ",
      "                                ",
      "16,15"
    };

    struct ViewState
    {
      bool showDepthMarker;

      KeyboardEvents::Dispatcher *keyboardDispatcher;
      MouseEvents::Dispatcher *mouseDispatcher;
      Window *window;
      X3D::Viewer *viewer;
      string initialViewpointName;
      CoordSystem3x3 defaultViewpoint;

      Vector3 trackballPos;
      double trackballRadius;
      bool sensorMode;
      bool mousePositionChanged;
      Ref<Window::MouseCursor> defaultMouseCursor;
      Ref<Window::MouseCursor> sensorMouseCursor;

      ViewState(KeyboardEvents::Dispatcher *k,
                MouseEvents::Dispatcher *m,
                Window *w,
                X3D::Viewer *viewer,
                string initialViewpointName,
                const CoordSystem3x3 &defaultViewpoint):
        showDepthMarker(false),
        keyboardDispatcher(k),
        mouseDispatcher(m),
        window(w),
        viewer(viewer),
        initialViewpointName(initialViewpointName),
        defaultViewpoint(defaultViewpoint),
        trackballRadius((window->getWidth() < window->getHeight() ?
                         window->getWidth() : window->getHeight())/2-1),
        sensorMode(false),
        mousePositionChanged(false),
        defaultMouseCursor(w->newMouseCursor(defaultMouseCursorData)),
        sensorMouseCursor(w->newMouseCursor(sensorMouseCursorData))
      {
      }

      Vector3 findTrackballPos(unsigned x, unsigned y)
      {
        Vector3 p(x-window->getWidth()/2.0, window->getHeight()/2.0-y, 0);
        p /= trackballRadius;
        double s = p.squareSum();

        // Clamp to sphere
        if(s>1)
        {
          p /= sqrt(s);
          s = 1;
        }

        p[2] = sqrt(1-s);
        return p;
      }

      void depthMarkerModeOn()
      {
        showDepthMarker = true;
        mouseDispatcher->setMode(4);
        keyboardDispatcher->setMode(1);
      }

      void depthMarkerModeOff()
      {
        showDepthMarker = false;
        mouseDispatcher->setMode(0);
        keyboardDispatcher->setMode(0);
      }

      void trackballMode(unsigned x, unsigned y, bool press)
      {
        mouseDispatcher->setMode(press ? 1 : 0);
        keyboardDispatcher->setMode(press ? 1 : 0);
        trackballPos = findTrackballPos(x, y);
      }

      void trackballDepthMode(unsigned x, unsigned y, bool press)
      {
        if(press)
        {
          if(showDepthMarker)
          {
            showDepthMarker = false;
            mouseDispatcher->setMode(0);
            keyboardDispatcher->setMode(0);
          }
          else
          {
            showDepthMarker = true;
            mouseDispatcher->setMode(4);
            keyboardDispatcher->setMode(1);
          }
        }
      }

      void trackballChangeDepthMode(unsigned x, unsigned y, bool press)
      {
        mouseDispatcher->setMode(press ? 5 : 4);
      }

      void travelMode(unsigned, unsigned, bool press)
      {
        mouseDispatcher->setMode(press ? 2 : 0);
        keyboardDispatcher->setMode(press ? 1 : 0);
      }

      void yawAndPitchMode(unsigned, unsigned, bool press)
      {
        mouseDispatcher->setMode(press ? 3 : 0);
        keyboardDispatcher->setMode(press ? 1 : 0);
      }

      void changeDepth(unsigned xAbs, unsigned yAbs, int xRel, int yRel)
      {
        viewer->setDepthOfRotation(viewer->getDepthOfRotation() + yRel);
      }

      void trackballRoll(unsigned xAbs, unsigned yAbs, int xRel, int yRel)
      {
        Vector3 p = findTrackballPos(xAbs, yAbs);

        if(p == trackballPos) return;

        Vector3 d = Vector3(0, 0, -viewer->getDepthOfRotation());
        CoordSystem3x3 &view = viewer->manipViewCoordSystem();
        view.translate(d);
        view.basis.rotate(Rotation3(normalize(trackballPos * p), -2*acos(dot(trackballPos, p))));
        view.translate(-d);
        trackballPos = p;
      }

      void travel(unsigned xAbs, unsigned yAbs, int xRel, int yRel)
      {
        //      double zRel = yRel * viewer->manipDepthOfRotation()/100;

        viewer->setDepthOfRotation(viewer->getDepthOfRotation() + yRel);
        CoordSystem3x3 &view = viewer->manipViewCoordSystem();
        view.translate(Vector3(0, 0, yRel));
      }

      void yawAndPitch(unsigned xAbs, unsigned yAbs, int xRel, int yRel)
      {
        CoordSystem3x3 &view = viewer->manipViewCoordSystem();
        view.basis.yaw(M_PI*xRel/1000);
        view.basis.pitch(M_PI*yRel/1000);
      }

      void resetViewpoint()
      {
        viewer->resetViewpoint(initialViewpointName, defaultViewpoint);
      }

      void disregardSensorsOn()
      {
        viewer->setDisregardSensors(true);
      }

      void disregardSensorsOff()
      {
        viewer->setDisregardSensors(false);
      }

      void sensorTrack(unsigned, unsigned, int, int)
      {
        mousePositionChanged = true;
      }

      void sensorActivate(unsigned, unsigned, bool press)
      {
        viewer->setPointingDeviceActive(press);
      }

      void toggleHeadLight()
      {
        viewer->setHeadLight(!viewer->getHeadLight());
      }

      void toggleShowLightSources()
      {
        viewer->setShowLightSources(!viewer->getShowLightSources());
      }

      void toggleWireframeMode()
      {
        viewer->setWireframeMode(!viewer->getWireframeMode());
      }

      void toggleEnableTexture()
      {
        viewer->setEnableTexture(!viewer->getEnableTexture());
      }

      void toggleShowNormals()
      {
        viewer->setShowNormals(!viewer->getShowNormals());
      }

      void toggleTextAsQuadsMode()
      {
        viewer->setTextAsQuadsMode(!viewer->getTextAsQuadsMode());
      }

      void toggleSeparateSpecularColorMode()
      {
        viewer->setSeparateSpecularColorMode(!viewer->getSeparateSpecularColorMode());
        cerr << "SeparateSpecularColor: " << viewer->getSeparateSpecularColorMode() << "\n";
      }

      void toggleLightModelLocalViewerMode()
      {
        viewer->setLightModelLocalViewerMode(!viewer->getLightModelLocalViewerMode());
        cerr << "LightModelLocalViewer: " << viewer->getLightModelLocalViewerMode() << "\n";
      }
    };

    void viewScene(Ref<X3D::Server> server,
                   string initialViewpointName,
                   const CoordSystem3x3 &viewCoordSystem,
                   double fieldOfView,
                   double depthOfRotation,
                   const Vector4 &backgroundColor,
                   int xResolution, int yResolution,
                   bool fullScreen,
                   bool showLightSources,
                   bool headLight,
                   bool wireframeMode,
                   bool enableTexture,
                   bool useMipmapedTextures,
                   bool showNormals,
                   bool textAsQuadsMode,
                   int subdivisionX,
                   int subdivisionY,
                   double frameRate)
    {
      bool quit = false;
      KeyboardEvents::Dispatcher kDisp(2);

      /*
       * Mouse modes
       *
       * mode  description    button 1         button 2          button 3
       * ----------------------------------------------------------------------
       *  0    default        trackball (1)    travel            yaw/pitch
       *                      depth marker (4) 
       *  1    trackball
       *  2    travel
       *  3    yaw/pitch
       *  4    depth marker   depth adjust (5)
       *                      default (0)
       *  5    depth adjust
       *  6    over sensor    activate
       * ----------------------------------------------------------------------
       */
      MouseEvents::Dispatcher mDisp(3, 7, 2);
      WindowQuitHandler windowQuitHandler(quit);
      Window window(xResolution, yResolution, 32, fullScreen, true,
                    &kDisp, &mDisp, &windowQuitHandler);

      X3D::Viewer viewer(server, xResolution, yResolution,
                         useMipmapedTextures,
                         initialViewpointName,
                         viewCoordSystem,
                         fieldOfView,
                         depthOfRotation,
                         backgroundColor,
                         subdivisionX, subdivisionY,
                         headLight,
                         showLightSources,
                         showNormals,
                         textAsQuadsMode,
                         wireframeMode, enableTexture);

      viewer.setInitialPointingDevicePosition2D(Vector2(window.getMouseX(), window.getMouseY()));
      window.discardEventQueue();

      ViewState state(&kDisp, &mDisp, &window, &viewer,
                      initialViewpointName, viewCoordSystem);

      window.setMouseCursor(state.defaultMouseCursor);

      KeyboardEvents::MethodCall<ViewState>
        kDepthMarker(&state,
                     &Console3d::ViewState::depthMarkerModeOn,
                     &Console3d::ViewState::depthMarkerModeOff);
      KeyboardEvents::VarAssign<bool> kQuit(quit, true, true);
      KeyboardEvents::MethodCall<ViewState> kResetViewpoint
        (&state, &ViewState::resetViewpoint, 0);
      KeyboardEvents::MethodCall<ViewState> kDisregardSensors
        (&state, &ViewState::disregardSensorsOn, &ViewState::disregardSensorsOff);
      KeyboardEvents::MethodCall<ViewState> kHeadLight
        (&state, &ViewState::toggleHeadLight, 0);
      KeyboardEvents::MethodCall<ViewState> kShowLightSources
        (&state, &ViewState::toggleShowLightSources, 0);
      KeyboardEvents::MethodCall<ViewState> kWireframeMode
        (&state, &ViewState::toggleWireframeMode, 0);
      KeyboardEvents::MethodCall<ViewState> kEnableTexture
        (&state, &ViewState::toggleEnableTexture, 0);
      KeyboardEvents::MethodCall<ViewState> kShowNormals
        (&state, &ViewState::toggleShowNormals, 0);
      KeyboardEvents::MethodCall<ViewState> kTextAsQuadsMode
        (&state, &ViewState::toggleTextAsQuadsMode, 0);
      KeyboardEvents::MethodCall<ViewState> kSeparateSpecularColorMode
        (&state, &ViewState::toggleSeparateSpecularColorMode, 0);
      KeyboardEvents::MethodCall<ViewState> kLightModelLocalViewerMode
        (&state, &ViewState::toggleLightModelLocalViewerMode, 0);

      kDisp.setHandler(key_z, &kDepthMarker, 0);
      kDisp.setHandler(key_escape, &kQuit, 0);
      kDisp.setHandler(key_space, &kDisregardSensors, 0);
      kDisp.setHandler(key_home, &kResetViewpoint, 0);
      kDisp.setHandler(key_h, &kHeadLight, 0);
      kDisp.setHandler(key_l, &kShowLightSources, 0);
      kDisp.setHandler(key_w, &kWireframeMode, 0);
      kDisp.setHandler(key_t, &kEnableTexture, 0);
      kDisp.setHandler(key_n, &kShowNormals, 0);
      kDisp.setHandler(key_e, &kTextAsQuadsMode, 0);
      kDisp.setHandler(key_f1, &kSeparateSpecularColorMode, 0);
      kDisp.setHandler(key_f2, &kLightModelLocalViewerMode, 0);

      MouseEvents::MotionMethod<ViewState>
        mTrackballRoll(&state, &Console3d::ViewState::trackballRoll);
      MouseEvents::MotionMethod<ViewState>
        mTravel(&state, &Console3d::ViewState::travel);
      MouseEvents::MotionMethod<ViewState>
        mYawAndPitch(&state, &Console3d::ViewState::yawAndPitch);
      MouseEvents::MotionMethod<ViewState>
        mChangeDepth(&state, &Console3d::ViewState::changeDepth);
      MouseEvents::MotionMethod<ViewState>
        mSensorTrack(&state, &Console3d::ViewState::sensorTrack);
      MouseEvents::ButtonMethod<ViewState>
        mTrackballMode(&state, &Console3d::ViewState::trackballMode);
      MouseEvents::ButtonMethod<ViewState>
        mTrackballDepthMode(&state, &Console3d::ViewState::trackballDepthMode);
      MouseEvents::ButtonMethod<ViewState>
        mTrackballChangeDepthMode(&state, &Console3d::ViewState::trackballChangeDepthMode);
      MouseEvents::ButtonMethod<ViewState>
        mTravelMode(&state, &Console3d::ViewState::travelMode);
      MouseEvents::ButtonMethod<ViewState>
        mYawAndPitchMode(&state, &Console3d::ViewState::yawAndPitchMode);
      MouseEvents::ButtonMethod<ViewState>
        mActivateSensor(&state, &Console3d::ViewState::sensorActivate);

      mDisp.setMulticlickLimit(0, 2);

      // Mode 0 (default)
      mDisp.setMotionHandler(&mSensorTrack, 0);
      mDisp.setButtonHandler(0, &mTrackballMode,      0, 1);
      mDisp.setButtonHandler(0, &mTrackballDepthMode, 0, 2);
      mDisp.setButtonHandler(1, &mTravelMode,         0, 1);
      mDisp.setButtonHandler(2, &mYawAndPitchMode,    0, 1);

      // Mode 1 (trackball)
      mDisp.setMotionHandler(&mTrackballRoll, 1);

      // Mode 2 (travel)
      mDisp.setMotionHandler(&mTravel, 2);

      // Mode 3 (yaw/pitch)
      mDisp.setMotionHandler(&mYawAndPitch, 3);

      // Mode 4 (depth marker)
      mDisp.setButtonHandler(0, &mTrackballChangeDepthMode, 4, 1);
      mDisp.setButtonHandler(0, &mTrackballDepthMode,       4, 2);

      // Mode 5 (depth adjust)
      mDisp.setMotionHandler(&mChangeDepth, 5);

      // Mode 6 (over sensor)
      mDisp.setMotionHandler(&mSensorTrack, 6);
      mDisp.setButtonHandler(0, &mActivateSensor, 6, 1);


      Time timePerFrame;
      timePerFrame.setNanoSeconds(long(1E9/frameRate));

      // A magic workaround for something that seems like a weird bug
      // in ATIs fglrx driver version 8.10.19.
      //glMatrixMode(GL_TEXTURE);
      //glScalef(1, 1, 1);
      //glMatrixMode(GL_MODELVIEW);

      glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
      glEnable(GL_BLEND);

      while(!quit)
      {
        Time start = Time::now();

        window.executeEventQueue(Time::now().getMilliSeconds());

        glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);

        glDisable(GL_LIGHTING);
        glDisable(GL_TEXTURE_2D);

        if(state.showDepthMarker)
        {
          glLoadIdentity();
          drawDepthMarker(viewer.getDepthOfRotation());
        }

        if(state.mousePositionChanged)
        {
          if(mDisp.getMode() == 0 || mDisp.getMode() == 6)
            viewer.setPointingDevicePosition2D(Vector2(window.getMouseX(),
                                                       window.getMouseY()));
          state.mousePositionChanged = false;
        }

        viewer.renderFrame();

        bool overOrDrag = viewer.getOverStatus() || viewer.getDragStatus();

        if(overOrDrag && mDisp.getMode() != 6)
        {
          window.setMouseCursor(state.sensorMouseCursor);
          mDisp.setMode(6);
          mDisp.setMulticlickLimit(0, 1);
          kDisp.setMode(1);
        }
        else if(!overOrDrag && mDisp.getMode() == 6)
        {
          window.setMouseCursor(state.defaultMouseCursor);
          mDisp.setMode(0);
          mDisp.setMulticlickLimit(0, 2);
          kDisp.setMode(0);
        }

        int e = glGetError();
        if(e) ARCHON_THROW1(InternalException, "GL error: "+Text::toString(e));

        window.swapBuffers();

        Time used = Time::now()-start;
        Thread::sleep(timePerFrame-used);
      }
    }
  }
}

---