NurbsSurface.h

Go to the documentation of this file.

/* $Id: NurbsSurface.h,v 1.1.1.1 2002/07/01 14:44:18 cvs Exp $ */

#ifndef __NURBS_SURFACE_H
#define __NURBS_SURFACE_H

#include <opennurbs.h>
#include <esg/Definitions.h>
#include <esg/geometry/Geometry.h>
#include <esg/geometry/Surface.h>
#include <esg/Intersector.h>
#include <esg/AutoPtr.h>
#include <esg/spacesorting/SDS.h>

namespace esg {

class NurbsSurface : public Geometry {
protected:
    Surface * _pSurface;    
    
protected:
    void _triangulate_surface (const ON_NurbsSurface&,
                               const SDS&,
                               AutoPtr<Intersector>*);

    virtual Mesh* _mesh                 (int /* density */) const;
    virtual void  _duplicate_attributes (const Geometry& src);

    // Geometric transformations
    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);
    
    NurbsSurface () {}
    
public:

        NurbsSurface (const SDS&            ss,
                      AutoPtr<Intersector>* it,
                      int                   dimension,
                      bool                  ratinal,
                      int                   order0,
                      int                   order1,
                      int                   count0,
                      int                   count1);

        NurbsSurface(const SDS&             ss,
                     AutoPtr<Intersector>*  it,
                     const ON_NurbsSurface& sp);

        virtual ~NurbsSurface ();

        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) {
            if (_pSurface) _pSurface->randomSample(mask, pe, pdf);
            else pe.mask = ENV_HAVE_NOTHING;
        }

        virtual bool randomDirection (const Vector3& pov,
                                      Vector3&       dir,
                                      double*        pdf) {
            return ((_pSurface) ?
                    _pSurface->randomDirection(pov,dir,pdf) :
                    false);
        }

        virtual Interval extent (const Vector3& direction) const;

        virtual Vector3 centroid (void) const;

        virtual double radius (void) const;

        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);
};

}; // namespace

#endif // __NURBS_SURFACE_H

---