engine.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 <archon/util/window.H>
#include <archon/util/time.H>
#include <archon/util/thread.H>
#include <archon/util/kdtree.H>
#include <archon/util/adaptive_skip.H>
#include <archon/util/color.H>
#include <archon/util/image.H>
#include <archon/util/progress_meter.H>

#include "options.H"
#include "world.H"
#include "engine.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

using namespace std;

namespace Archon
{
  using namespace Utilities;
  using namespace Math;

  namespace Raytracer
  {
    void flush(Window *window, vector<Vector4> &pixels,
               unsigned &frameX, unsigned &frameY)
    {
      Window::Update update(window);
      for(unsigned i=0; i<pixels.size(); ++i)
      {
        unsigned red   = unsigned(pixels[i][0] * 256); if(red   >= 256) red   = 255;
        unsigned green = unsigned(pixels[i][1] * 256); if(green >= 256) green = 255;
        unsigned blue  = unsigned(pixels[i][2] * 256); if(blue  >= 256) blue  = 255;
        update.drawPoint(frameX, frameY, Window::set, red, green, blue);
        ++frameX;
        if(frameX == window->getWidth())
        {
          frameX = 0;
          --frameY;
        }
      }

      pixels.clear();
    }

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

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

      void quit()
      {
        quitFlag = true;
        cout << "\n";
      }
    };

    void Engine::render(World *world, View view)
    {
      if(opt_generatePhotonMap)
        world->photonTrace(opt_causticPhotons);

      const double aspect = double(opt_resolution.y) / opt_resolution.x;

      Vector2 viewPlane;

      if(aspect < 1)
      {
        viewPlane[1] = 2*tan(view.fieldOfView/2);
        viewPlane[0] = viewPlane[1] / aspect;
      }
      else
      {
        viewPlane[0] = 2*tan(view.fieldOfView/2);
        viewPlane[1] = viewPlane[0] * aspect;
      }

      Vector3 viewPlaneLowerLeft = view.coordSystem.origin;
      viewPlaneLowerLeft -= view.coordSystem.basis.x * viewPlane[0] / 2;
      viewPlaneLowerLeft -= view.coordSystem.basis.y * viewPlane[1] / 2;
      viewPlaneLowerLeft -= view.coordSystem.basis.z;

      Vector3 viewPlaneHorizontalSpan = view.coordSystem.basis.x;
      viewPlaneHorizontalSpan *= viewPlane[0];

      Vector3 viewPlaneVerticalSpan = view.coordSystem.basis.y;
      viewPlaneVerticalSpan *= viewPlane[1];

      Window *window = 0;
      AdaptiveSkip skip(100);
      vector<Vector4> pixels;
      unsigned frameX = 0;
      unsigned frameY = opt_resolution.y - 1;

      bool quit = false;

      WindowQuitHandler windowQuitHandler(quit);

      if(opt_displayRendering)
        window = new Window(opt_resolution.x, opt_resolution.y,
                                    32, false, false, 0, 0, &windowQuitHandler);

      Image image(opt_resolution.x, opt_resolution.y);

      ProgressStatus progress(opt_resolution.x * opt_resolution.y);

      unsigned extraSkip = 0;

      for(int y = 0; y<opt_resolution.y; ++y)
      {
        Vector3 vy(viewPlaneVerticalSpan);
        vy *= double(y) / opt_resolution.y;

        for(int x = 0; x<opt_resolution.x; ++x)
        {
          Vector3 v(viewPlaneHorizontalSpan);
          v *= double(x) / opt_resolution.x;
          v += vy;
          v += viewPlaneLowerLeft;
          v -= view.coordSystem.origin;
          v.normalize();

          Vector4 c = world->trace(Line3(view.coordSystem.origin, v));
          image.setPixel(x, y, c[0], c[1], c[2], c[3]);

          if(c[0] >= 1) c[0] = 1;
          if(c[1] >= 1) c[1] = 1;
          if(c[2] >= 1) c[2] = 1;
          if(c[3] >= 1) c[3] = 1;

          // Blend with background of gray tiles ala The Gimp
          double tile = ((x/16+y/16)%2 ? 0.5 : 0.7) * (1-c[3]);
          c[0] = c[3] * c[0] + tile;
          c[1] = c[3] * c[1] + tile;
          c[2] = c[3] * c[2] + tile;
          c[3] = 1;

          pixels.push_back(c);

          progress.tick();

          if(opt_displayRendering && skip.tick())
          {
            window->executeEventQueue(Time::now().getMilliSeconds());
            if(++extraSkip == 10)
            {
              flush(window, pixels, frameX, frameY);
              extraSkip = 0;
            }
          }

          if(quit) break;
        }
        if(quit) break;
      }

      if(opt_displayRendering) flush(window, pixels, frameX, frameY);

      image.save(opt_outputFileName, "", 0, logger);

      if(opt_displayRendering) while(!quit)
      {
        window->executeEventQueue(Time::now().getMilliSeconds());
        Thread::sleep(Time(0, 100000000));
      }
    }
  }
}

---