geometry.H

Go to the documentation of this file.

/*
 * 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_GEOMETRY_H
#define ARCHON_X3D_GEOMETRY_H

#include <archon/x3d/server/geoprop.H>
#include <archon/x3d/server/texture.H>
#include <archon/x3d/server/appear.H>

namespace Archon
{
  namespace X3D
  {
    struct RenderConfig
    {
      int subdivision1;

      int subdivision2;

      bool showNormals;

      Vector3 normalColor;
      double normalLength;

      bool wireframeMode;
      bool textAsQuadsMode;

      RenderConfig(int subdivision1,
                   int subdivision2,
                   bool showNormals,
                   double normalLength,
                   bool wireframeMode,
                   bool textAsQuadsMode):
        subdivision1(subdivision1),
        subdivision2(subdivision2),
        showNormals(showNormals),
        normalColor(1, 0, 0),
        normalLength(normalLength),
        wireframeMode(wireframeMode),
        textAsQuadsMode(textAsQuadsMode) {}
    };

    struct Shape;

    struct GeometryNode: virtual Node
    {
      static const NodeType *type;

      virtual int intersect(const Math::Ray3 &, double &dist) const = 0;

      virtual void getNormalAndTexCoord(Vector3 hitPoint, int where,
                                        const Shape *,
                                        Vector3 *hitNormal,
                                        Vector2 *hitTexCoord) const = 0;

      virtual void render(bool texture,
                          const Shape *shape,
                          const RenderConfig *) = 0;

    protected:
      GeometryNode() {}
    };


    struct Geometry3DNode: GeometryNode
    {
      static const NodeType *type;

    protected:
      Geometry3DNode() {}
    };


    struct Box: Geometry3DNode
    {
      static Ref<NodeBase> instantiate(BackRef<ExecutionContext> c)
      {
        return new Box(c);
      }

      static const NodeType *type;
      const NodeType *getType() const { return type; }

      Box(BackRef<ExecutionContext> c): NodeBase(c), size(2, 2, 2) {}

      const Vector3 &getSize() const { return size; }

      int intersect(const Math::Ray3 &, double &dist) const;

      void getNormalAndTexCoord(Vector3 hitPoint, int where,
                                const Shape *,
                                Vector3 *hitNormal,
                                Vector2 *hitTexCoord) const;

      void render(bool texture,
                  const Shape *shape,
                  const RenderConfig *);

    private:
      friend void initializeGeometryComponent();

      Vector3 size;
    };


    struct Cone: Geometry3DNode
    {
      static Ref<NodeBase> instantiate(BackRef<ExecutionContext> c)
      {
        return new Cone(c);
      }

      static const NodeType *type;
      const NodeType *getType() const { return type; }

      Cone(BackRef<ExecutionContext> c):
        NodeBase(c), bottomRadius(1),
        height(2), side(true), bottom(true) {}

      double getBottomRadius() const { return bottomRadius; }
      double getHeight()       const { return height;       }
      bool   getSide()         const { return side;         }
      bool   getBottom()       const { return bottom;       }

      int intersect(const Math::Ray3 &, double &dist) const;

      void getNormalAndTexCoord(Vector3 hitPoint, int where,
                                const Shape *,
                                Vector3 *hitNormal,
                                Vector2 *hitTexCoord) const;

      void render(bool texture,
                  const Shape *shape,
                  const RenderConfig *);

    private:
      friend void initializeGeometryComponent();

      double bottomRadius;
      double height;
      bool   side;
      bool   bottom;
    };


    struct Cylinder: Geometry3DNode
    {
      static Ref<NodeBase> instantiate(BackRef<ExecutionContext> c)
      {
        return new Cylinder(c);
      }

      static const NodeType *type;
      const NodeType *getType() const { return type; }

      Cylinder(BackRef<ExecutionContext> c):
        NodeBase(c), height(2), radius(1),
        side(true), top(true), bottom(true) {}

      double getHeight() const { return height; }
      double getRadius() const { return radius; }
      bool   getSide()   const { return side;   }
      bool   getTop()    const { return top;    }
      bool   getBottom() const { return bottom; }

      int intersect(const Math::Ray3 &, double &dist) const;

      void getNormalAndTexCoord(Vector3 hitPoint, int where,
                                const Shape *,
                                Vector3 *hitNormal,
                                Vector2 *hitTexCoord) const;

      void render(bool texture,
                  const Shape *shape,
                  const RenderConfig *);

    private:
      friend void initializeGeometryComponent();

      double height;
      double radius;
      bool   side;
      bool   top;
      bool   bottom;
    };


    struct IndexedLineSet: Geometry3DNode
    {
      static Ref<NodeBase> instantiate(BackRef<ExecutionContext> c)
      {
        return new IndexedLineSet(c);
      }

      static const NodeType *type;
      const NodeType *getType() const { return type; }

      IndexedLineSet(BackRef<ExecutionContext> c):
        NodeBase(c), colorPerVertex(true), lineWidth(1) {}

      Ref<ColorNode>      getColor() const { return color; }
      Ref<CoordinateNode> getCoord() const { return coord; }
      vector<int>         getColorIndex() const { return colorIndex; }
      bool                getColorPerVertex() const { return colorPerVertex; }
      vector<int>         getCoordIndex() const { return coordIndex; }
      double              getLineWidth() const { return lineWidth; }

      int intersect(const Math::Ray3 &, double &dist) const { return 0; }
      void getNormalAndTexCoord(Vector3, int, const Shape *,
                                Vector3 *, Vector2 *) const {};

      void render(bool texture,
                  const Shape *shape,
                  const RenderConfig *);

    private:
      friend void initializeGeometryComponent();

      Ref<ColorNode>      color;          // [in,out] NULL [X3DColorNode]
      Ref<CoordinateNode> coord;          // [in,out] NULL [X3DCoordinateNode]
      vector<int>         colorIndex;     // []       []   [0,inf) or -1
      bool                colorPerVertex; // []       TRUE
      vector<int>         coordIndex;     // []       []   [0,inf) or -1
      double              lineWidth;      // []       1    [1,inf)

      EventSource colorChanged;
      EventSource coordChanged;

      Time colorStamp;
      Time coordStamp;
      Time colorIndexStamp;
      Time coordIndexStamp;
    };

    struct PointSet: Geometry3DNode
    { 
      static Ref<NodeBase> instantiate(BackRef<ExecutionContext> c)
      {
        return new PointSet(c);
      }

      static const NodeType *type;
      const NodeType *getType() const { return type; }

      PointSet(BackRef<ExecutionContext> c): NodeBase(c) {}

      Ref<ColorNode>      getColor() const { return color; }
      Ref<CoordinateNode> getCoord() const { return coord; }

      int intersect(const Math::Ray3 &, double &dist) const { return 0; }
      void getNormalAndTexCoord(Vector3, int, const Shape *,
                                Vector3 *, Vector2 *) const {};

      void render(bool texture,
                  const Shape *shape,
                  const RenderConfig *);

    private:
      friend void initializeGeometryComponent();

      Ref<ColorNode>      color; // [in,out] NULL [X3DColorNode]
      Ref<CoordinateNode> coord; // [in,out] NULL [X3DCoordinateNode]

      EventSource colorChanged;
      EventSource coordChanged;

      Time colorStamp;
      Time coordStamp;
    };


    struct Sphere: Geometry3DNode
    {
      static Ref<NodeBase> instantiate(BackRef<ExecutionContext> c)
      {
        return new Sphere(c);
      }

      static const NodeType *type;
      const NodeType *getType() const { return type; }

      Sphere(BackRef<ExecutionContext> c): NodeBase(c), radius(1) {}

      double getRadius() const { return radius; }

      int intersect(const Math::Ray3 &, double &dist) const;

      void getNormalAndTexCoord(Vector3 hitPoint, int where,
                                const Shape *,
                                Vector3 *hitNormal,
                                Vector2 *hitTexCoord) const;

      void render(bool texture,
                  const Shape *shape,
                  const RenderConfig *);

    private:
      friend void initializeGeometryComponent();

      double radius;
    };

    struct ComposedGeometryNode: Geometry3DNode
    {
      static const NodeType *type;

      bool getCCW()             const { return ccw; }
      bool getColorPerVertex()  const { return colorPerVertex; }
      bool getNormalPerVertex() const { return normalPerVertex; }
      bool getSolid()           const { return solid; }

      Ref<const CoordinateNode>        getCoord()    const { return coord; }
      Ref<      CoordinateNode>        getCoord()          { return coord; }
      Ref<const ColorNode>             getColor()    const { return color; }
      Ref<      ColorNode>             getColor()          { return color; }
      Ref<const NormalNode>            getNormal()   const { return normal; }
      Ref<      NormalNode>            getNormal()         { return normal; }
      Ref<const TextureCoordinateNode> getTexCoord() const { return texCoord; }
      Ref<      TextureCoordinateNode> getTexCoord()       { return texCoord; }

    protected:
      ComposedGeometryNode():
        ccw(true),
        colorPerVertex(true),
        normalPerVertex(true),
        solid(true) {}

      friend class Viewer;
      friend void initializeGeometryComponent();

      bool ccw;
      bool colorPerVertex;
      bool normalPerVertex;
      bool solid;

      Ref<CoordinateNode>        coord;
      Ref<ColorNode>             color;
      Ref<NormalNode>            normal;
      Ref<TextureCoordinateNode> texCoord;

      bool coordAssign(const Ref<CoordinateNode> &,           const Time &);
      bool colorAssign(const Ref<ColorNode> &,                const Time &);
      bool normalAssign(const Ref<NormalNode> &,              const Time &);
      bool texCoordAssign(const Ref<TextureCoordinateNode> &, const Time &);

      EventSource colorChanged;
      EventSource coordChanged;
      EventSource normalChanged;
      EventSource texCoordChanged;

      Time colorStamp;
      Time coordStamp;
      Time normalStamp;
      Time texCoordStamp;

      virtual void reprocess() {};
    };


    struct ElevationGrid: ComposedGeometryNode
    {
      static Ref<NodeBase> instantiate(BackRef<ExecutionContext> c)
      {
        return new ElevationGrid(c);
      }

      static const NodeType *type;
      const NodeType *getType() const { return type; }

      ElevationGrid(BackRef<ExecutionContext> c):
        NodeBase(c), creaseAngle(0),
        xDimension(0), xSpacing(1), zDimension(0), zSpacing(1) {}

      double getCreaseAngle()           const { return creaseAngle; }
      const vector<double> &getHeight() const { return height;      }
      int    getXDimension()            const { return xDimension;  }
      double getXSpacing()              const { return xSpacing;    }
      int    getZDimension()            const { return zDimension;  }
      double getZSpacing()              const { return zSpacing;    }

      int intersect(const Math::Ray3 &, double &dist) const;

      void getNormalAndTexCoord(Vector3 hitPoint, int where,
                                const Shape *,
                                Vector3 *hitNormal,
                                Vector2 *hitTexCoord) const;

      void render(bool texture,
                  const Shape *shape,
                  const RenderConfig *);

    private:
      friend void initializeGeometryComponent();

      double         creaseAngle;
      vector<double> height;
      int            xDimension;
      double         xSpacing;
      int            zDimension;
      double         zSpacing;

      Time heightStamp;
    };


    struct IndexedFaceSet: ComposedGeometryNode
    {
      static Ref<NodeBase> instantiate(BackRef<ExecutionContext> c)
      {
        return new IndexedFaceSet(c);
      }

      static const NodeType *type;
      const NodeType *getType() const { return type; }

      IndexedFaceSet(BackRef<ExecutionContext> c):
        NodeBase(c), convex(true), creaseAngle(0), preprocessed(false) {}

      bool getConvex()          const { return convex; }
      double getCreaseAngle()   const { return creaseAngle; }

      // -1 seperates faces
      // Indices into 'coord'
      const vector<int> &getCoordIndex()    const { return coordIndex; }
      // Indices into 'color'
      const vector<int> &getColorIndex()    const { return colorIndex; }
      // Indices into 'normal'
      const vector<int> &getNormalIndex()   const { return normalIndex; }
      // Indices into 'texCoord'
      const vector<int> &getTexCoordIndex() const { return texCoordIndex; }

      int intersect(const Math::Ray3 &, double &dist) const;

      void getNormalAndTexCoord(Vector3 hitPoint, int where,
                                const Shape *,
                                Vector3 *hitNormal,
                                Vector2 *hitTexCoord) const;

      void render(bool texture,
                  const Shape *shape,
                  const RenderConfig *);

    private:
      friend void initializeGeometryComponent();

      bool convex;
      double creaseAngle;

      vector<int>  coordIndex;
      vector<int>  colorIndex;
      vector<int>  normalIndex;
      vector<int>  texCoordIndex;

      bool coordIndexAssign(const vector<int> &,    const Time &);
      bool colorIndexAssign(const vector<int> &,    const Time &);
      bool normalIndexAssign(const vector<int> &,   const Time &);
      bool texCoordIndexAssign(const vector<int> &, const Time &);

      Time colorIndexStamp;
      Time coordIndexStamp;
      Time normalIndexStamp;
      Time texCoordIndexStamp;

      void reprocess();

      void preprocess();

      bool preprocessed;
      const vector<Vector3> *coords;
      const vector<Vector3> *rgbColors;
      const vector<Vector4> *rgbaColors;
      const vector<Vector3> *normals;
      const vector<Vector2> *texCoords;
      vector<int> preprocessedCoordIndex;
      vector<int> preprocessedColorIndex;
      vector<int> preprocessedNormalIndex;
      vector<int> preprocessedTexCoordIndex;
      vector<Vector3> preprocessedNormal;
      Vector3 preprocessedBboxCenter;
      Vector3 preprocessedBboxSize;
    };


    struct ShapeNode: virtual ChildNode
    {
      static const NodeType *type;

    protected:
      ShapeNode() {}
    };


    struct Shape: ShapeNode, BoundedObject
    {
      static Ref<NodeBase> instantiate(BackRef<ExecutionContext> c)
      {
        return new Shape(c);
      }

      static const NodeType *type;
      const NodeType *getType() const { return type; }

      Shape(BackRef<ExecutionContext> c): NodeBase(c), drawCache(0) {}

      Ref<const AppearanceNode> getAppearance() const { return appearance; }
      Ref<      AppearanceNode> getAppearance()       { return appearance; }
      Ref<const GeometryNode> getGeometry() const { return geometry; }
      Ref<      GeometryNode> getGeometry()       { return geometry; }

      struct DrawCache
      {
        virtual ~DrawCache() {}

        virtual void dispose() = 0;
      };

      DrawCache *drawCache;

      virtual ~Shape()
      {{ // The extra scope is needed to work around gcc3.2 bug #8287
        if(drawCache) drawCache->dispose();
      }}

    private:
      friend void initializeGeometryComponent();

      Ref<AppearanceNode> appearance;
      Ref<GeometryNode>   geometry;

      EventSource appearanceChanged;
      EventSource geometryChanged;

      Time appearanceStamp;
      Time geometryStamp;
    };
  }
}

#endif // ARCHON_X3D_GEOMETRY_H

---