view.H

/*
 * 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).
 */

#ifndef ARCHON_RENDER_VIEW_H
#define ARCHON_RENDER_VIEW_H

#include <archon/math/vector.H>

#include <archon/util/ref.H>

namespace Archon
{
  namespace Render
  {
    using namespace std;
    using namespace Math;
    using namespace Utilities;

    struct Renderer: RefObjectBase
    {
      virtual void initOpenGlContext() = 0;

      virtual void render() = 0;
    };


    struct Viewport;
    struct Screen;
    struct Eye;
    struct Clip;
    struct Channel;
    struct Pipe;

    struct View: RefObjectBase
    {
      static Ref<View> create(Ref<Renderer> r)
      {
        return new View(r);
      }

    private:
      View(Ref<Renderer> r): renderer(r) {}

      friend struct Viewport;
      friend struct Screen;
      friend struct Eye;
      friend struct Clip;
      friend struct Channel;

      const Ref<Renderer> renderer;
      Mutex viewMutex;
    };


    struct Viewport: RefObjectBase
    {
      static Ref<Viewport> create(Ref<View> v) { return new Viewport(v); }

      void set(double left, double bottom,
               double width, double height)
      {
        Mutex::Lock l(view->viewMutex);
        this->left   = left;
        this->bottom = bottom;
        this->width  = width;
        this->height = height;
      }

    private:
      Viewport(Ref<View> v):
        view(v), left(0), bottom(0), width(1), height(1) {}

      friend struct Channel;
      friend struct Pipe;

      const Ref<View> view;

      double left, bottom;
      double width, height;
    };


    struct Screen: RefObjectBase
    {
      static Ref<Screen> create(Ref<View> v) { return new Screen(v); }

      void set(Vector3 center, Vector3 x, Vector3 y,
               double halfWidth, double halfHeight)
      {
        Mutex::Lock l(view->viewMutex);
        this->center     = center;
        this->x          = x;
        this->y          = y;
        this->halfWidth  = halfWidth;
        this->halfHeight = halfHeight;
      }

      void set(double aspectRatio,
               double fieldOfView = M_PI/4,
               double distance = 1)
      {
        double w = distance * tan(fieldOfView/2);
        double h = w;
        if(aspectRatio > 1) w *= aspectRatio;
        else h /= aspectRatio;

        set(Vector3(0, 0, -distance),
            Vector3(1, 0, 0), Vector3(0, 1, 0), w, h);
      }

    private:
      Screen(Ref<View> v): view(v) { set(1, M_PI/4); }

      friend struct Channel;
      friend struct Pipe;

      const Ref<View> view;

      Vector3 center;
      Vector3 x, y;
      double halfWidth, halfHeight;
    };


    struct Eye: RefObjectBase
    {
      static Ref<Eye> create(Ref<View> v) { return new Eye(v); }

      void set(Vector3 position)
      {
        Mutex::Lock l(view->viewMutex);
        this->position = position;
      }

    private:
      Eye(Ref<View> v): view(v), position(Vector3(0, 0, 0)) {}

      friend struct Channel;
      friend struct Pipe;

      const Ref<View> view;

      Vector3 position;
    };


    struct Clip: RefObjectBase
    {
      static Ref<Clip> create(Ref<View> v) { return new Clip(v); }
      
      void set(double near, double far)
      {
        Mutex::Lock l(view->viewMutex);
        this->near = near;
        this->far  = far;
      }

    private:
      Clip(Ref<View> v): view(v), near(0.2), far(200) {}

      friend struct Channel;
      friend struct Pipe;

      const Ref<View> view;

      double near, far;
    };
  }
}

#endif // ARCHON_RENDER_VIEW_H

---