context.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/render/context.H>

#include <archon/render/conductor.H>

namespace Archon
{
  namespace Render
  {
    void Channel::render(const Ref<Pipe> &pipe)
    {
      Display::Bind bind(pipe->context, window);

      if(!pipe->initialized)
      {
        view->renderer->initOpenGlContext();
        pipe->initialized = true;
      }

      double l, b, w, h;
      Vector3 c, x, y;
      double s, t;
      Vector3 e;
      double n, f;

      // Fetch the view information
      {
        Mutex::Lock lock(view->viewMutex);
        l = viewport->left;
        b = viewport->bottom;
        w = viewport->width;
        h = viewport->height;
        c = screen->center;
        x = screen->x;
        y = screen->y;
        s = screen->halfWidth;
        t = screen->halfHeight;
        e = eye->position;
        n = clip->near;
        f = clip->far;
      }

      // Determine the canonical coordinate system of the eye
      Vector3 z = x;
      z *= y;

      // Determine the center of the screen in the canonical coordinate
      // system of the eye
      c -= e;
      c.set(dot(c, x), dot(c, y), dot(c, z));

      // Setup the projection matrix
      double a = n / -c[2];
      glMatrixMode(GL_PROJECTION);
      glLoadIdentity();
      glFrustum((c[0] - s) * a, (c[0] + s) * a,
                (c[1] - t) * a, (c[1] + t) * a, n, f);

      /*
      cerr << "w:\t"
           << ((c[0] - s) * a) << ",\t"
           << ((c[0] + s) * a) << ",\t"
           << ((c[1] - t) * a) << ",\t"
           << ((c[1] + t) * a) << ",\t"
           << n << ",\t" << f << "\n";
      */

      // Setup the modelview matrix
      GLdouble m[16] =
      {
        x[0],       y[0],       z[0],       0,
        x[1],       y[1],       z[1],       0,
        x[2],       y[2],       z[2],       0,
        -dot(x, e), -dot(y, e), -dot(z, e), 1
      };
      glMatrixMode(GL_MODELVIEW);
      glLoadMatrixd(m);

      /*
      cerr
        << m[0] << "\t" << m[4] << "\t" << m[ 8] << "\t" << m[12] << "\n"
        << m[1] << "\t" << m[5] << "\t" << m[ 9] << "\t" << m[13] << "\n"
        << m[2] << "\t" << m[6] << "\t" << m[10] << "\t" << m[14] << "\n"
        << m[3] << "\t" << m[7] << "\t" << m[11] << "\t" << m[15] << "\n";
      */

      // Setup the viewport (with strict round-off controll)
      s = window->getWidth();
      t = window->getHeight();
      unsigned il = static_cast<unsigned>(l * s + 0.5);
      unsigned ib = static_cast<unsigned>(b * t + 0.5);
      unsigned iw = static_cast<unsigned>((l+w) * s + 0.5) - il;
      unsigned ih = static_cast<unsigned>((b+h) * t + 0.5) - ib;
      glViewport(il, ib, iw, ih);

      view->renderer->render();
    }


    void Pipe::addChannel(Ref<Conductor> conductor,
                          Ref<View> view,
                          Ref<Display::Window> window,
                          Ref<Viewport> viewport,
                          Ref<Screen> screen,
                          Ref<Eye> eye,
                          Ref<Clip> clip)
    {
      if(view != viewport->view ||
         view !=   screen->view ||
         view !=      eye->view ||
         view !=     clip->view)
        ARCHON_THROW1(ArgumentException,
                      "Illegal combination - different View objects found");
      conductor->addWindow(window, this);
      Mutex::Lock l(channelMutex);
      channels.push_back(Channel(view, window, viewport, screen, eye, clip));
    }

    void Pipe::render()
    {
      Ref<Pipe> pipe(this);
      Mutex::Lock l(channelMutex);
      for(unsigned i=0; i<channels.size(); ++i) channels[i].render(pipe);
    }
  }
}

---