render.C

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

#include <cmath>
#include <string>
#include <iostream>
#include <algorithm>

#include <archon/math/vector.H>

#include <archon/util/options.H>
#include <archon/util/text.H>
#include <archon/util/thread.H>

#include <archon/display/implementation.H>
#include <archon/display/connection.H>
#include <archon/display/screen.H>
#include <archon/display/visual.H>
#include <archon/display/window.H>
#include <archon/display/context.H>
#include <archon/display/keysyms.H>

namespace Archon
{
  using namespace Math;

  namespace Display
  {
    namespace Test
    {
      bool    opt_help                     = false;
      double  opt_frameRate                = 30;
      Options::IntByInt opt_windowSize     = { 500, 500 };
      Options::IntByInt opt_windowPosition = { 0, 0 };
      Options::IntByInt opt_screenDpcm     = { 0, 0 };
      double  opt_eyeToScreenDist          = 0.4; // 40 cm
      double  opt_depthOfField             = 100;
      double  opt_interestBallRadius       = 4;
      double  opt_detailLevel              = 1;
      bool    opt_directRendering          = true;

      unsigned adjust(unsigned val, unsigned min, double f)
      {
        return std::max(static_cast<unsigned>(f*val), min);
      }

      unsigned adjustDetail(unsigned val, unsigned min)
      {
        return adjust(val, min, opt_detailLevel);
      }

      struct PerspectiveProjection
      {
        double horizontalDotPitch;

        double verticalDotPitch;

        double viewDistance;

        double aspectRatio;

        double neutralFieldOfView;

        double farToNearClipRatio;

        double zoomFactor;

        double cameraDistance;



        PerspectiveProjection(double horizontalDotPitch = 0.0254/96, double verticalDotPitch = 0.0254/96,
                              double viewDistance = 0.4, double aspectRatio = 1, double neutralFieldOfView = 0.828427124747,
                              double farToNearClipRatio = 100, double zoomFactor = 1, double cameraDistance = 10):
          horizontalDotPitch(horizontalDotPitch), verticalDotPitch(verticalDotPitch),
          viewDistance(viewDistance), aspectRatio(aspectRatio), neutralFieldOfView(neutralFieldOfView),
          farToNearClipRatio(farToNearClipRatio), zoomFactor(zoomFactor), cameraDistance(cameraDistance) {}



        double getHorizontalResolutionDpcm()
        {
          return 0.01 / horizontalDotPitch;
        }

        double getVerticalResolutionDpcm()
        {
          return 0.01 / verticalDotPitch;
        }

        void setResolutionDpcm(double h, double v)
        {
          horizontalDotPitch = 0.01 / h;
          verticalDotPitch   = 0.01 / v;
        }



        double getHorizontalResolutionDpi()
        {
          return 0.0254 / horizontalDotPitch;
        }

        double getVerticalResolutionDpi()
        {
          return 0.0254 / verticalDotPitch;
        }

        void setResolutionDpi(double h, double v)
        {
          horizontalDotPitch = 0.0254 / h;
          verticalDotPitch   = 0.0254 / v;
        }



        double getViewportWidthMeters()
        {
          return  viewDistance * zoomFactor * getActualHorizontalFieldOfView();
        }

        int getViewportWidthPixels()
        {
          return lround(getViewportWidthMeters() / horizontalDotPitch);
        }

        double getViewportHeightMeters()
        {
          return  viewDistance * zoomFactor * getActualVerticalFieldOfView();
        }

        int getViewportHeightPixels()
        {
          return lround(getViewportHeightMeters() / verticalDotPitch);
        }

        void setViewportSizeMeters(double width, double height)
        {
          aspectRatio = width / height;
          neutralFieldOfView = sqrt(width * height) / viewDistance;
        }

        void setViewportSizePixels(int width, int height)
        {
          setViewportSizeMeters(width * horizontalDotPitch, height * verticalDotPitch);
        }



        double getNearClipDist()
        {
          return cameraDistance / sqrt(farToNearClipRatio);
        }

        double getFarClipDist()
        {
          return getNearClipDist() * farToNearClipRatio;
        }

        double getNearClipWidth()
        {
          return getNearClipDist() * getActualHorizontalFieldOfView();
        }

        double getNearClipHeight()
        {
          return getNearClipDist() * getActualVerticalFieldOfView();
        }



        void autoDistance(double interest, double f = 1)
        {
          cameraDistance = interest * sqrt(0.25 + sq(zoomFactor / neutralFieldOfView / f));
        }

        void autoZoom(double interest, double f = 1)
        {
          zoomFactor = neutralFieldOfView * f * sqrt(sq(cameraDistance/interest) - 0.25);
        }



        double getActualHorizontalFieldOfView()
        {
          return neutralFieldOfView / zoomFactor * getHorizontalFieldFactor();
        }

        double getActualVerticalFieldOfView()
        {
          return neutralFieldOfView / zoomFactor * getVerticalFieldFactor();
        }



        double getNeutralSolidAngleOfView()
        {
          return 4 * atan(1 / sqrt(4/sq(neutralFieldOfView) + aspectRatio + 1/aspectRatio));
        }

        void setNeutralSolidAngleOfView(double v)
        {
          neutralFieldOfView = sqrt(4/(sq(1/tan(v/4)) - aspectRatio - 1/aspectRatio));
        }


        double getActualSolidAngleOfView()
        {
          return 4 * atan(1 / sqrt(4/sq(neutralFieldOfView/zoomFactor) + aspectRatio + 1/aspectRatio));
        }

        void setActualSolidAngleOfView(double v)
        {
          neutralFieldOfView = zoomFactor * sqrt(4/(sq(1/tan(v/4)) - aspectRatio - 1/aspectRatio));
        }



        double getNeutralAngleOfView(double f = 1)
        {
          return 2 * atan(f*neutralFieldOfView/2);
        }

        void setNeutralAngleOfView(double v, double f = 1)
        {
          neutralFieldOfView = 2 * sqrt(tan(v/2)) / f;
        }


        double getActualAngleOfView(double f = 1)
        {
          return 2 * atan(f*neutralFieldOfView/zoomFactor/2);
        }

        void setActualAngleOfView(double v, double f = 1)
        {
          neutralFieldOfView = 2 * zoomFactor * sqrt(tan(v/2)) / f;
        }



        double getMeanFieldFactor()
        {
          return 1;
        }

        double getHorizontalFieldFactor()
        {
          return sqrt(aspectRatio);
        }

        double getVerticalFieldFactor()
        {
          return 1/sqrt(aspectRatio);
        }

        double getDiagonalFieldFactor()
        {
          return sqrt(aspectRatio + 1/aspectRatio);
        }

        double getMinimumFieldFactor()
        {
          return sqrt(min(aspectRatio, 1/aspectRatio));
        }

        double getMaximumFieldFactor()
        {
          return sqrt(max(aspectRatio, 1/aspectRatio));
        }
      };


      PerspectiveProjection projection;

      void resize(int w, int h)
      {
        glViewport(0, 0, w, h);
        projection.setViewportSizePixels(w, h);
        projection.autoDistance(2*opt_interestBallRadius, projection.getMinimumFieldFactor());

        double viewPlaneDist   = projection.getNearClipDist();
        double viewPlaneRight  = projection.getNearClipWidth() / 2;
        double viewPlaneTop    = projection.getNearClipHeight() / 2;
        double farClippingDist = projection.getFarClipDist();

        //cerr << "Camera distance     = " << projection.cameraDistance << " obj" << endl;
        //cerr << "Near clip distance  = " << viewPlaneDist << " obj" << endl;
        //cerr << "Far clip distance   = " << farClippingDist << " obj" << endl;

        glMatrixMode(GL_PROJECTION);
        glLoadIdentity();
        glFrustum(-viewPlaneRight, viewPlaneRight, -viewPlaneTop, viewPlaneTop, viewPlaneDist, farClippingDist);
      }

      void init(int w, int h)
      {
        resize(w, h);

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

        glEnable(GL_LIGHTING);
        glEnable(GL_LIGHT0);
        glEnable(GL_DEPTH_TEST);
        glEnable(GL_COLOR_MATERIAL);

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

        v[0] = v[1] = v[2] = 0.9;
        glLightfv(GL_LIGHT0, GL_DIFFUSE, v);

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

        glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL, GL_SEPARATE_SPECULAR_COLOR);
        glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, 1);
        glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, 1);

        v[0] = 0.9; v[1] = 0.9; v[2] = 0.9;
        glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, v);

        glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, 32);

        glColorMaterial(GL_FRONT_AND_BACK, GL_DIFFUSE);
      }

      void render(double w)
      {
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

        glMatrixMode(GL_MODELVIEW);
        glLoadIdentity();
        Vector3 camera(-1,3,-19);
        camera.normalize();
        camera *= projection.cameraDistance;
        gluLookAt(camera[0], camera[1], camera[2], 0, 0, 0, 0, 1, 0);

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

        v[0] = 25; v[1] = 100; v[2] = -25;
        glLightfv(GL_LIGHT0, GL_POSITION, v);

        glRotated(w/M_PI*180, 0, 1, 0);

        GLUquadric *quadric = gluNewQuadric();

        glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
        gluSphere(quadric, opt_interestBallRadius, 50, 50);
        glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);

        glPushMatrix();
        glColor3f(0.1, 0.9, 0.9);
        glTranslated(0, 0, -16);
        gluCylinder(quadric, 0.2, 0.2, 1.6,
                    adjustDetail(50, 3), adjustDetail(25, 1));
        glPopMatrix();

        glPushMatrix();
        glColor3f(0.2, 0.2, 0.8);
        glTranslated(0, 0, -12.5);
        gluCylinder(quadric, 0.2, 0.2, 1.6,
                    adjustDetail(50, 3), adjustDetail(25, 1));
        glPopMatrix();

        glPushMatrix();
        glColor3f(0.9, 0.1, 0.9);
        glTranslated(0, 0, -9);
        gluCylinder(quadric, 0.2, 0.2, 1.6,
                    adjustDetail(50, 3), adjustDetail(25, 1));
        glPopMatrix();

        glPushMatrix();
        glColor3f(0.2, 0.2, 0.8);
        glTranslated(0, 0, -5.5);
        gluCylinder(quadric, 0.2, 0.2, 1.6,
                    adjustDetail(50, 3), adjustDetail(25, 1));
        glPopMatrix();

        glPushMatrix();
        glColor3f(0.9, 0.9, 0.1);
        glTranslated(0, 0, -2);
        gluCylinder(quadric, 0.2, 0.2, 1.6,
                    adjustDetail(50, 3), adjustDetail(25, 1));
        glPopMatrix();

        glPushMatrix();
        glColor3f(0.2, 0.2, 0.8);
        glTranslated(0, 0, 1.5);
        gluCylinder(quadric, 0.2, 0.2, 1.6,
                    adjustDetail(50, 3), adjustDetail(25, 1));
        glPopMatrix();

        glPushMatrix();
        glColor3f(0.8, 0.3, 0.3);
        glTranslated(-0.07, 0, -60.5);
        gluCylinder(quadric, 0.02, 0.02, 64,
                    adjustDetail(25, 3), adjustDetail(200, 1));
        glPopMatrix();

        glPushMatrix();
        glColor3f(0.8, 0.3, 0.3);
        glTranslated(+0.07, 0, -60.5);
        gluCylinder(quadric, 0.02, 0.02, 64,
                    adjustDetail(25, 3), adjustDetail(200, 1));
        glPopMatrix();

        gluDeleteQuadric(quadric);
      }

      void measureFrameRate()
      {
        static Time next = Time::now() + Time(10.0);
        static double frames = 0;

        ++frames;

        while(Time::now() >= next)
        {
          cerr << "Frame rate (f/s): " << frames/10 << "\n";
          frames = 0;
          next += Time(10.0);
        }
      }

      struct EventHandler: Display::EventHandler
      {
        void resize(int w, int h) { Test::resize(w, h); }
        void close()              { run   = false; }
        void mouseIn()            { animate = true;  }
        void mouseOut()           { animate = false; }
        void keyDown(KeySym s)    { if(s == KeySym_q || s == KeySym_Escape) run = false; }

        bool run;
        bool animate;

        EventHandler(): run(true), animate(false) {}
      };

      int main(int argc, const char *argv[])
      {
        Options o;

        o.addSwitch("h", "help", opt_help, true,
                    "Describe the parameters");
        o.addConfig("f", "frame-rate", opt_frameRate, opt_frameRate,
                    "Upper limit on number of frames per second.",
                    Options::wantArg_always);
        o.addConfig("s", "window-size", opt_windowSize, opt_windowSize,
                    "Initial size in pixels of the windows contents area.",
                    Options::wantArg_always);
        o.addConfig("p", "window-position", opt_windowPosition, opt_windowPosition,
                    "Initial position in pixels of the upper left corner of the outside window frame.",
                    Options::wantArg_always);
        o.addConfig("r", "screen-dpcm", opt_screenDpcm, opt_screenDpcm,
                    "Horizontal by vertical dots per centimeter on the target screen. "
                    "Specify 0x0 to use the figures reported by the system.\n"
                    "If you have it in dots per inch (dpi) devide it by  2.54 cm/in to get dots per centimeter (dpcm).\n"
                    "Specifying the wrong values here will produce the wrong field of view, "
                    "which in turn will produce the wrong aspect ratio between the Z axis and the X-Y plane, "
                    "which in turn leads to the depth effect appearing either stretched or squeezed. "
                    "It may also produce the wrong aspect ratio between the X and Y axes, "
                    "which will lead to circles in the X Y plane appearing egg-shaped.",
                    Options::wantArg_always);
        o.addConfig("e", "eye-to-screen-dist", opt_eyeToScreenDist, opt_eyeToScreenDist,
                    "Distance in meters between your eyes and the screen.\n"
                    "Specifying the wrong distance here will produce the wrong field of view, "
                    "which in turn will produce the wrong aspect ratio between the Z axis and the X-Y plane, "
                    "which in turn leads to the depth effect appearing either stretched or squeezed.",
                    Options::wantArg_always);
        o.addConfig("d", "depth-of-field", opt_depthOfField, opt_depthOfField,
                    "Ratio between near and far clipping planes. Must be greater than 1.\n"
                    "Smaller values produce more accurate depth tests but makes it more likely that your scene will be clipped.",
                    Options::wantArg_always);
        o.addConfig("i", "interest-ball-radius", opt_interestBallRadius, opt_interestBallRadius,
                    "Radius of the interest ball in object coordinates.",
                    Options::wantArg_always);
        o.addConfig("l", "detail-level", opt_detailLevel, opt_detailLevel,
                    "A detail level modifier or factor. 1 corresponds to the normal level of detail. "
                    "2 corresponds to twice the normal level of detail.",
                    Options::wantArg_always);
        o.addConfig("D", "direct-rendering", opt_directRendering, opt_directRendering,
                    "Attempt to establist direct rendering contexts to gain performance.",
                    Options::wantArg_always);

        if(o.processCommandLine(argc, argv))
        {
          cerr << "Try --help\n";
          return 1;
        }
  
        if(opt_help)
        {
          cout <<
            "Test Application for the Archon::Display library\n"
            "by Brian Kristiansen & Kristian Spangsege\n"
            "\n"
            "Synopsis: " << argv[0] << "\n"
            "\n"
            "Available options:\n";
          cout << o.list();
          return 0;
        }

        if(argc > 1)
        {
          cerr << "Too many aguments\n";
          cerr << "Try --help\n";
          return 1;
        }

        Ref<Display::Implementation> implementation = Display::getDefaultImplementation();
        Ref<Display::Connection> connection = implementation->newConnection();
        Ref<Display::Screen> screen = connection->getDefaultScreen();

        projection.horizontalDotPitch = opt_screenDpcm.x ? 0.01 / opt_screenDpcm.x : screen->getHorizontalDotPitch();
        projection.verticalDotPitch   = opt_screenDpcm.y ? 0.01 / opt_screenDpcm.y : screen->getVerticalDotPitch();
        projection.viewDistance       = opt_eyeToScreenDist;
        cerr << "Horizontal dot pitch = " << projection.horizontalDotPitch << " m/px" << endl;
        cerr << "Vertical dot pitch   = " << projection.verticalDotPitch << " m/px" << endl;

        Ref<Display::Visual> visual = screen->chooseVisual();

        Ref<Display::Window> window = visual->newWindow(opt_windowPosition.x, opt_windowPosition.y,
                                                        opt_windowSize.x, opt_windowSize.y, "Archon::Display::Test");

        Ref<Display::Context> context = visual->newContext(opt_directRendering);

        cerr << "Direct rendering context: " << context->isDirect() << endl;

        double w = 0;

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

        Display::Bind bind(context, window);

        init(opt_windowSize.x, opt_windowSize.y);

        EventHandler eventHandler;

        Time t = Time::now();
        while(eventHandler.run)
        {
          measureFrameRate();

          render(w);

          window->processEvents(&eventHandler);

          window->swapBuffers();

          if(eventHandler.animate) w += 2*M_PI/opt_frameRate/10;

          t += timePerFrame;
          Thread::sleepUntil(t);
        }

        return 0;
      }
    }
  }
}

int main(int argc, const char *argv[]) throw()
{
  using namespace Archon::Utilities;

  std::set_unexpected(Exception::terminal<Archon::Display::exceptionCatchInfo>);
  std::set_terminate (Exception::terminal<Archon::Display::exceptionCatchInfo>);

  return Archon::Display::Test::main(argc, argv);
}

---