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_X3D_VIEW_H
#define ARCHON_X3D_VIEW_H

#include <stack>
#include <set>

#include <archon/math/coord_system.H>

#include <archon/x3d/server/exception.H>
#include <archon/x3d/server/x3d.H>
#include <archon/x3d/server/scene.H>

namespace Archon
{
  namespace X3D
  {
    struct Viewer
    {
      Viewer(Ref<Server>,
             int resolutionX, int resolutionY,
             bool useMipmapedTextures,
             string initialViewpointName,
             const CoordSystem3x3 &defaultViewpoint,
             double fieldOfView,
             double depthOfRotation,
             const Vector4 &backgroundColor,
             int subdivisionX, int subdivisionY,
             bool headLight,
             bool showLightSources,
             bool showNormals,
             bool textAsQuadsMode,
             bool wireframeMode,
             bool enableTexture);

      bool bindViewpoint(string name);

      void resetViewpoint(string initialViewpointName,
                          const CoordSystem3x3 &defaultViewpoint);
      void setPointingDeviceActive(bool m);

      void setInitialPointingDevicePosition2D(Vector2);

      void setPointingDevicePosition2D(Vector2);

      void renderFrame();

      bool getOverStatus() const { return !pointingDeviceOverSet.empty(); }

      bool getDragStatus() const { return !pointingDeviceActiveSet.empty(); }

      bool getHeadLight() const               { return headLight; }
      void setHeadLight(bool m = true)        { headLight = m; }

      bool getShowLightSources() const        { return showLightSources; }
      void setShowLightSources(bool m = true) { showLightSources = m; }

      bool getDisregardSensors() const        { return disregardSensors; }
      void setDisregardSensors(bool m = true) { disregardSensors = m; }

      bool getEnableTexture() const           { return enableTexture; }
      void setEnableTexture(bool m = true)    { enableTexture = m; }

      bool getWireframeMode() const
      {
        return renderConfig.wireframeMode;
      }

      void setWireframeMode(bool m = true)
      {
        renderConfig.wireframeMode = m;
        updateShapeCacheDuringNextFrame = true; // Text nodes need this.
      }

      bool getShowNormals() const
      {
        return renderConfig.showNormals;
      }

      void setShowNormals(bool m = true)
      {
        renderConfig.showNormals = m;
        updateShapeCacheDuringNextFrame = true;
      }

      bool getTextAsQuadsMode() const
      {
        return renderConfig.textAsQuadsMode;
      }

      void setTextAsQuadsMode(bool m = true)
      {
        renderConfig.textAsQuadsMode = m;
        updateShapeCacheDuringNextFrame = true;
      }

      bool getSeparateSpecularColorMode() const        { return separateSpecularColorMode; }
      void setSeparateSpecularColorMode(bool m = true) { separateSpecularColorMode = m; }

      bool getLightModelLocalViewerMode() const        { return lightModelLocalViewerMode; }
      void setLightModelLocalViewerMode(bool m = true) { lightModelLocalViewerMode = m ; }

      CoordSystem3x3 &manipViewCoordSystem()
      {
        boundViewpoint = 0;
        return viewCoordSystem;
      }

      double getDepthOfRotation() const
      {
        return depthOfRotation;
      }

      void setDepthOfRotation(double d)
      {
        boundViewpoint = 0;
        depthOfRotation = d;
        renderConfig.normalLength = d/10;
      }

    private:
      unsigned maxLights;

      Ref<Server> server;

      const int resolutionX;
      const int resolutionY;
      const double aspectRatio;

      const double nearClippingDist;
      const double farClippingDist;

      const bool useMipmapedTextures;

      CoordSystem3x3 viewCoordSystem;
      double fieldOfView;
      double depthOfRotation;

      Ref<const Viewpoint> boundViewpoint;

      Vector2 viewPlane;

      RenderConfig renderConfig;

      bool headLight;
      bool showLightSources;
      bool disregardSensors;

      bool enableTexture;

      bool separateSpecularColorMode;
      bool lightModelLocalViewerMode;

      int numberOfEnabledLights;
      bool tracePointingRay;
      Vector3 pointingRay; // Direction vector is generally does not have unit length
      vector<const GroupingNode *> hitGroupThread;
      vector<Rotation3> hitGroupThreadBillboardRotations; // One entry for each Billboard pointer in hitGroupThread in the same order
      int hitGroupThreadLowerLevel;
      int level; // Nesting level of groups, 0 is root group

      bool updateShapeCacheDuringNextFrame;

      set<Ref<PointingDeviceSensorNode> > pointingDeviceOverSet;   // The isOver set
      set<Ref<PointingDeviceSensorNode> > pointingDeviceActiveSet; // The isActive set
      bool anyActiveDragSensors;
      Vector2 pointingDevicePosition; // For conventional 2-D mice
      bool pointingDevicePositionChangedSinceLastFrame;
      bool pointingDeviceActive;
      bool pointingDeviceLastActive; // Value of pointingDeviceActive at last frame
      CoordSystem3x3 eyeToSensorMap; // For mapping pointing ray while dragging
      Vector3 initialDragHitPoint; // In the inverse eyeToSensorMap coordinate system
      Sphere3 virtualSphereSensor;
      double virtualCylinderSensorRadius;
      double virtualCylinderSensorAngle;

      void setupViewpoint();
      Viewpoint *findBoundViewpoint_group
      (const GroupingNode *, stack<const Transform *> *transformPath=0);
      Viewpoint *findBoundViewpoint_child
      (ChildNode *, stack<const Transform *> *transformPath=0);

      void calculateBillboardRotation(const Billboard *, Rotation3 &);

      void setupLight(bool headLight, bool showLightSources);
      void lightPointLight(const PointLight *, int &, bool);
      void lightSpotLight(const SpotLight *, int &, bool);
      void lightDispatchLightNode(const LightNode *, int &, bool);
      void lightTransform(const Transform *, int &, bool);
      void lightBillboard(const Billboard *, int &, bool);
      void lightSwitch(const Switch *, int &, bool);
      void lightDispatchGroupingNode(const GroupingNode *, int &, bool);
      void lightGroupingNode(const GroupingNode *, int &, bool);

      void dispatchChildNode(const ChildNode *);
      void drawGroupingNode(GroupingNode *, bool, const Rotation3 *billboardRotation = 0);
      void dispatchGroupingNode(GroupingNode *, bool);
      void drawTransform(Transform *, bool);
      void drawBillboard(Billboard *, bool);
      void drawSubSceneNode(SubSceneNode *, bool);
      Shape *drawShape(ShapeNode *);

      struct Hit
      {
        const Shape *node;
        int where;
        double distance;
        Math::Ray3 localRay;
      };

      Hit hit;

      struct ShapeCache;
    };
  }
}

#endif // ARCHON_X3D_VIEW_H

---