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/thread.H>
#include <archon/util/window.H>
#include <archon/util/keyboard.H>
#include <archon/util/mouse.H>
#include <archon/util/color.H>

#include "engine.H"
#include "sceneloader.H"
#include "scene_view.H"

#if ! defined M_PI
#define M_E           2.7182818284590452353602874713526625  /* e */
#define M_LOG2E       1.4426950408889634073599246810018922  /* log_2 e */
#define M_LOG10E      0.4342944819032518276511289189166051  /* log_10 e */
#define M_LN2         0.6931471805599453094172321214581766  /* log_e 2 */
#define M_LN10        2.3025850929940456840179914546843642  /* log_e 10 */
#define M_PI          3.1415926535897932384626433832795029  /* pi */
#define M_PI_2        1.5707963267948966192313216916397514  /* pi/2 */
#define M_PI_4        0.7853981633974483096156608458198757  /* pi/4 */
#define M_1_PI        0.3183098861837906715377675267450287  /* 1/pi */
#define M_2_PI        0.6366197723675813430755350534900574  /* 2/pi */
#define M_2_SQRTPI    1.1283791670955125738961589031215452  /* 2/sqrt(pi) */
#define M_SQRT2       1.4142135623730950488016887242096981  /* sqrt(2) */
#define M_SQRT1_2     0.7071067811865475244008443621048490  /* 1/sqrt(2) */
#endif

namespace Archon
{
  using namespace Math;
  using namespace Utilities;

  namespace Raytracer
  {
    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;

      glEnable(GL_POINT_SMOOTH);
      glEnable(GL_LINE_SMOOTH);
      glPointSize(1);
      glLineWidth(1);
      glColor3f(1, 1, 1);

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

      for(int i=0; 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 *sensorMouseCursorData[] =
    {
      //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 *overSensorMouseCursorData[] =
    {
      //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;
      double markerDepth;    

      KeyboardEvents::Dispatcher *keybordDispatcher;
      MouseEvents::Dispatcher *mouseDispatcher;
      Window *window;
      View *view;
      Vector3 trackballPos;
      double trackballRadius;
      bool sensorMode;
      bool sensorUpdate;
      Ref<Window::MouseCursor> sensorMouseCursor;
      Ref<Window::MouseCursor> overSensorMouseCursor;
      bool pointingDeviceActive;

      ViewState(KeyboardEvents::Dispatcher *k,
                MouseEvents::Dispatcher *m,
                Window *w,
                View *v):
        showDepthMarker(false),
        markerDepth(500),
        keybordDispatcher(k),
        mouseDispatcher(m),
        window(w),
        view(v),
        trackballRadius((window->getWidth() < window->getHeight() ? window->getWidth() : window->getHeight())/2-1),
        sensorMode(false),
        sensorUpdate(false),
        sensorMouseCursor(w->newMouseCursor(sensorMouseCursorData)),
        overSensorMouseCursor(w->newMouseCursor(overSensorMouseCursorData)),
        pointingDeviceActive(false)
      {}

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

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

      void trackballMode(unsigned x, unsigned y, bool press)
      {
        mouseDispatcher->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);
          }
          else
          {
            showDepthMarker = true;
            mouseDispatcher->setMode(4);
          }
        }
      }

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

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

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

      void changeDepth(unsigned xAbs, unsigned yAbs, int xRel, int yRel)
      {
        markerDepth += 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, -markerDepth);
        view->coordSystem.translate(d);
        view->coordSystem.basis.rotate(Rotation3(normalize(trackballPos * p), -2*acos(dot(trackballPos, p))));
        view->coordSystem.translate(-d);
        trackballPos = p;
      }

      void travel(unsigned xAbs, unsigned yAbs, int xRel, int yRel)
      {
        markerDepth += yRel;
        view->coordSystem.translate(Vector3(0, 0, yRel));
      }

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

      void sensorModeOn()
      {
        mouseDispatcher->setMode(6);
        mouseDispatcher->setMulticlickLimit(0, 1);
        sensorMode = true;
        window->setMouseCursor(sensorMouseCursor);
        sensorUpdate = true;
      }

      void sensorModeOff()
      {
        mouseDispatcher->setMode(0);
        mouseDispatcher->setMulticlickLimit(0, 2);
        sensorMode = false;
        window->setDefaultMouseCursor();
        sensorUpdate = true;
      }

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

      void sensorActivate(unsigned, unsigned, bool press)
      {
        pointingDeviceActive = press;
        sensorUpdate = true;
      }
    };


    void viewScene(X3D::Scene *scene,
                   string viewPointName,
                   View *view, const Vector4 &backgroundColor,
                   int xResolution, int yResolution,
                   bool fullScreen,
                   bool showLightSources,
                   bool headLight,
                   int subdivisionX,
                   int subdivisionY,
                   int frameRate,
                   Logger *logger)
    {
      const double nearClippingDist = 1;
      const double farClippingDist = 2000;

      {
        vector<View> views;
        get_scene(scene, 0, 0, &views, 0, logger);

        if(viewPointName.empty())
        {
          if(views.size()) *view = views[0];
        }
        else
        {
          unsigned i = 0;
          for(;i<views.size(); ++i) if(viewPointName == views[i].name)
          {
            *view = views[i];
            break;
          }
          if(i == views.size())
          {
            logger->log("Viewpoint '" + viewPointName + "' is unknown");
            if(views.size()) *view = views[0];
          }
        }
      }

      bool quit = false;
      KeyboardEvents::Dispatcher kDisp(1);
      MouseEvents::Dispatcher mDisp(3, 7, 2);
      WindowQuitHandler windowQuitHandler(quit);
      Window window(xResolution, yResolution, 32, fullScreen, true,
                    &kDisp, &mDisp, &windowQuitHandler);

      window.discardEventQueue();

      ViewState state(&kDisp, &mDisp, &window, view);

      KeyboardEvents::MethodCall<ViewState>
        kDepthMarker(&state,
                     &Raytracer::ViewState::depthMarkerModeOn,
                     &Raytracer::ViewState::depthMarkerModeOff);
      KeyboardEvents::VarAssign<bool> kQuit(quit, true, true);
      KeyboardEvents::MethodCall<ViewState> kSensor(&state, &ViewState::sensorModeOn, &ViewState::sensorModeOff);
      KeyboardEvents::Toggle kHeadLight(headLight);
      KeyboardEvents::Toggle kShowLightSources(showLightSources);

      kDisp.setHandler(key_z, &kDepthMarker, 0);
      kDisp.setHandler(key_escape, &kQuit, 0);
      kDisp.setHandler(key_space, &kSensor, 0);
      kDisp.setHandler(key_h, &kHeadLight, 0);
      kDisp.setHandler(key_l, &kShowLightSources, 0);

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

      mDisp.setMotionHandler(&mTrackballRoll, 1);
      mDisp.setMotionHandler(&mTravel, 2);
      mDisp.setMotionHandler(&mYawAndPitch, 3);
      mDisp.setMotionHandler(&mChangeDepth, 5);
      mDisp.setMotionHandler(&mSensorTrack, 6);
      mDisp.setMulticlickLimit(0, 2);
      mDisp.setButtonHandler(0, &mTrackballMode,            0, 1);
      mDisp.setButtonHandler(0, &mTrackballDepthMode,       0, 2);
      mDisp.setButtonHandler(0, &mTrackballChangeDepthMode, 4, 1);
      mDisp.setButtonHandler(0, &mTrackballDepthMode,       4, 2);
      mDisp.setButtonHandler(1, &mTravelMode,               0, 1);
      mDisp.setButtonHandler(2, &mYawAndPitchMode,          0, 1);
      mDisp.setButtonHandler(0, &mActivateSensor,           6, 1);

      const double aspect = double(xResolution) / yResolution;
      const double viewPlaneRadius = nearClippingDist*tan(view->fieldOfView/2);

      Vector2 viewPlane;

      if(aspect > 1)
      {
        viewPlane[0] = viewPlaneRadius * aspect;
        viewPlane[1] = viewPlaneRadius;
      }
      else
      {
        viewPlane[0] = viewPlaneRadius;
        viewPlane[1] = viewPlaneRadius / aspect;
      }

      glViewport(0, 0, xResolution, yResolution);
      glMatrixMode(GL_PROJECTION);
      glLoadIdentity();
      glFrustum(-viewPlane[0], viewPlane[0], -viewPlane[1], viewPlane[1],
                nearClippingDist, farClippingDist);
      glMatrixMode(GL_MODELVIEW);
      glClearColor(backgroundColor[0], backgroundColor[1], backgroundColor[2], backgroundColor[3]);
      glDepthFunc(GL_LESS);
      glEnable(GL_DEPTH_TEST);                    

      X3D::Viewer viewer(scene, uriToComponentMap, subdivisionX, subdivisionY);
      bool wasOver = false;

      Time timePerFrame;
      timePerFrame.setNanoSeconds(1000000000l/frameRate);

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

        glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);

        glDisable(GL_LIGHTING);
        glDisable(GL_TEXTURE_2D);

        if(state.showDepthMarker)
        {
          glLoadIdentity();
          drawDepthMarker(state.markerDepth);
        }

        if(state.sensorMode && state.sensorUpdate)
        {
          Vector3 mousePoint;
          mousePoint[0] = viewPlane[0] * (2.0 * window.getMouseX() / xResolution - 1);
          mousePoint[1] = viewPlane[1] * (-2.0 * window.getMouseY() / yResolution + 1);
          mousePoint[2] = -nearClippingDist;

          bool isOver = viewer.view(view->coordSystem, headLight, showLightSources,
                                    state.pointingDeviceActive, &mousePoint);
          if(isOver && !wasOver)
            window.setMouseCursor(state.overSensorMouseCursor);
          else if(!isOver && wasOver)
            window.setMouseCursor(state.sensorMouseCursor);
          wasOver = isOver;

          state.sensorUpdate = false;
        }
        else viewer.view(view->coordSystem, headLight, showLightSources,
                         state.pointingDeviceActive, 0);

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

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

---