Surface.h

Go to the documentation of this file.

/* $Id: Surface.h,v 1.4 2002/11/05 14:31:15 anonymous Exp $ */

#ifndef __SURFACE_H
#define __SURFACE_H

#include <esg/geometry/Geometry.h>
#include <esg/spacesorting/SDS.h>
#include <esg/iterator/IteratorSDS.h>
#include <esg/Intersector.h>
#include <esg/AutoPtr.h>
#include <esg/AutoArray.h>
#include <esg/mesh/Mesh.h>
#include <esg/geometry/_Surface.h>

namespace esg {

class OGSCENE_EXPORT Surface : public Geometry {
    friend class NurbsSurface;
    
public:
    enum VertOrder {
        TRIANGLES,
        TRIANGLE_STRIP,
        TRIANGLE_FAN,
        QUADS,
        QUAD_STRIP
    };

protected:
    AutoArray<Vertex3> *   _pAutoVertices; // array of vertices
    AutoArray<Vector3> *   _pAutoNormals;  // array of vertex normals
    AutoArray<Vector2> *   _pAutoUVCoords; // array of vertex normals
    unsigned               _nVert;         // number of vertices
    unsigned               _nNorm;         // number of normals
    unsigned               _nUVCoords;     // number of normals
    SDS *                  _pRepository;   // space sub-division structure
    bool                   _created;       // is the whole structure finished?
    VertOrder              _vertOrder;     // how to interpret vertices
    IteratorSDS *          _pIterator;     // used for repository inspection
    AutoPtr<Intersector> * _pAutoInter;
    bool                   _fastMesh;
    unsigned               _nSurfaces;

    // abbreviations for auto pointers
    Vertex3 *      _vertices;   // array of vertices
    Vector3 *      _normals;    // array of vertex normals
    Vector2 *      _uvCoords;    // array of vertex normals
    Intersector *  _pIntersector;

    // attributes used only during creation
    Vector3   _auxPlaneNormal;   // normal verctor of next plane
    bool      _havePlaneNormal;  // its validity
    unsigned  _primVertIndices [4];  // array of indices
    unsigned  _primNormIndices [4];
    unsigned  _primUVIndices   [4];
    unsigned  _primVertices;     // number of primitives' corners (3 or 4)
    unsigned  _primActVert;      // actually processing corner

    // attributes used during inspection
    unsigned _vertIndex;

    // Speed up of ray intersection tests. When new ray originates at the point
    // of previous intersection then the test can be improved. The HitPoint
    // is just the structure remembering the sucessufull intersection
    // of previous pass.
    struct HitPoint {
        Vector3     point;
        const void* pSDSLeaf;
        HitPoint () : pSDSLeaf(NULL) {}
    } * _pPreviousHit;
    

protected:
            bool  _check_vertex (void);
    virtual Mesh* _mesh         (int /* not used */) const;
    virtual void  _duplicate_attributes (const Geometry&);
    virtual void  _rotateX      (float /* angle */);
    virtual void  _rotateY      (float /* angle */);
    virtual void  _rotateZ      (float /* angle */);
    virtual void  _rotate       (float /* angle */, const Vector3& /* axis */);
    virtual void  _rotate       (const Matrix3&);
    virtual void  _translate    (float /* x */, float /* y */, float /* z */);
    virtual void  _transform    (const Matrix4&);
    virtual void  _scale        (float);
    Surface () {}
    
public:

        Surface (const SDS&             ss,
                 AutoArray<Vertex3> *   va,
                 unsigned               nv,
                 AutoArray<Vector3> *   na,
                 unsigned               nn,
                 AutoArray<Vector2> *   uva,
                 unsigned               uvn,
                 enum VertOrder         vo,
                 AutoPtr<Intersector> * it,
                 bool                   fm);

        virtual ~Surface ();

        /********************************************************************/
        /* "local" methods of the Surface                                   */
        /********************************************************************/

        void normal (const Vector3& v);

        bool vertex (unsigned index);

        bool vertex (unsigned vindex, unsigned nindex);

        bool vertex (unsigned vindex, unsigned nindex, unsigned uvindex);

        bool vertexUV (unsigned vindex, unsigned uvindex);

        bool done (void);

        const _Surface* firstPlane (void);

        const _Surface* nextPlane  (void);

        inline unsigned numPlanes (void) const { return _nSurfaces; }

        inline bool firstVertex (void) {
            _vertIndex = 0;
            return ((_nVert) ? true : false);
        }

        inline bool nextVertex (void) {
            return ((++_vertIndex < _nVert) ? true : false);
        }

        inline Vertex3  actVertex (void) const {
            return _vertices[_vertIndex];
        }

        inline unsigned numVertices (void) const { return _nVert; }

        unsigned numEdges (void) const;


        /********************************************************************/
        /* methods of Geometry                                              */
        /********************************************************************/

        virtual void rayIntersection (PointEnv*      pPE,
                                      int            mask,
                                      const Vector3& origin,
                                      const Vector3& direction,
                                      float          maxD = MAXFLOAT);

        virtual bool mapToUV (const Vector3& v, Vector2& uv);
        
        virtual void randomSample (int mask, PointEnv& pe, double* pdf);

        virtual bool randomDirection (const Vector3& pov,
                                      Vector3&       dir,
                                      double*        pdf);

        virtual Interval extent (const Vector3& direction) const;

        virtual Vector3 centroid (void) const;

        virtual double radius (void) const { return radius(centroid()); }

        virtual double radius (const Vector3& centroid) const;

        virtual Geometry* clone (const Matrix4* pTrMat) const;

        virtual bool separation (Geometry& geom, Vector3*  pDir) {
            return false; // TO DO
        }

        virtual double distance (const Geometry& geom, Vector3* pDir) {
            return DBL_MIN; // TO DO
        }

        virtual void dump (const char* intent, const char* tab);



        virtual void __debug() {
            fprintf(stderr,"Surface:\n");
            if (_pRepository) _pRepository->__debug();
        }

        SDS* __get_repository() { return _pRepository; }
};

/*
 * speed up of ray intersection test when new ray originates at the point
 * of previous intersection
 */

}; // namespace

#endif // __SURFACE_H

---