GU/GU_RayPrimitive.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * Produced by:
 *      Mark Elendt
 *      Side Effects
 *      477 Richmond Street West
 *      Toronto, Ontario
 *      Canada   M5V 3E7
 *      416-504-9876
 *
 * NAME:        GU library (C++)
 *
 * COMMENTS:    Ray info - cached information for each primitive type
 *
 */

#ifndef __GU_RayPrimInfo_h__
#define __GU_RayPrimInfo_h__

#include "GU_API.h"
#include <UT/UT_Matrix4.h>
#include <UT/UT_Matrix3.h>
#include <UT/UT_Vector3.h>
#include <UT/UT_Vector4Array.h>
#include <UT/UT_Matrix.h>
#include <UT/UT_BoundingBox.h>
// Unfortnately, hard copyies are used...
#include "GU_RayRBezCurve.h"
#include "GU_RayRBezSurf.h"

class GEO_Point;
class GEO_Primitive;
class GU_RayInfo;
class GU_MinInfo;
class GU_RayRBezCurve;
class GU_RayRBezSurf;
class TS_MetaExpression;
class UT_BoundingRect;
class GU_IsectCurveSet;
class GU_IsectCurve;

class GU_API GU_Ray {
public:
    GU_Ray(const UT_Vector3 &o, const UT_Vector3 &d, const UT_Matrix4 *mat = 0);

    float               globalDist(float t) const       { return t / tscale; }
    float               localDist(float t) const        { return t * tscale; }

    UT_Vector3          org, dir;
    float               tscale;
};

// Finds intersection of ray & quad.
int
GU_getBilinearQuadIntersection(const UT_Vector3 &org, 
                            const UT_Vector3 &dir,
                            const UT_Vector3 &A, const UT_Vector3 &B,
                            const UT_Vector3 &C, const UT_Vector3 &D,
                            const UT_Vector3 &norm,
                            float &t, float &u, float &v, float &d2);
//________________________________________________________
//
//  Base class for primitive info
//________________________________________________________
//
class GU_API GU_RayPrimInfo {
public:
             GU_RayPrimInfo(const GEO_Primitive *prim);

    // TODO: Make pure virtual when compiler allows us
    virtual int         intersect(const UT_Vector3 &org,
                                  const UT_Vector3 &dir,
                                  GU_RayInfo &hitinfo);
    // NB: "t" value is position on this, (u,v) position
    // on passed in primitive.
    virtual int         intersect(GU_RayPrimInfo *prim,
                                  GU_RayInfo &hitinfo);
    virtual int         minimum(const UT_Vector3 &p, GU_MinInfo &mininfo);
    virtual int         minimum(GU_RayPrimInfo *prim, GU_MinInfo &mininfo);

    void                bumpRefCount(int dir);
    void                getXYProjection(const UT_Vector3 &nml, int &x, int &y);

    // Initialize if it is dirty.
    virtual void        init();

    const GEO_Primitive *getPrim() const    { return myPrim; }

public:
    const GEO_Primitive *myPrim;
    UT_BoundingBox       bbox;
    float                sortValue;
    int                  serial;                // Unique serial number
    unsigned             refCount:29,
                         degenerate:1,
                         subclassflag:1,
                         dirty:1;

protected:
    virtual ~GU_RayPrimInfo();
};

//________________________________________________________
//
//  Quadric ray intersection class
//________________________________________________________
//
class GU_API GU_RayQuadricInfo : public GU_RayPrimInfo
{
public:
             GU_RayQuadricInfo(const GEO_Primitive *prim);
    virtual ~GU_RayQuadricInfo();

    virtual int         intersect(const UT_Vector3 &org,
                                  const UT_Vector3 &dir,
                                  GU_RayInfo &hitinfo);
    virtual int         intersect(GU_RayPrimInfo *,GU_RayInfo &) 
                        { return -1; }

    virtual int         minimum(const UT_Vector3 &p, GU_MinInfo &mininfo);
    virtual int         minimum(GU_RayPrimInfo * /*prim*/, 
                                GU_MinInfo &/*mininfo*/)
                        { return 0; }
public:
    int                 circle(const GU_Ray &, GU_RayInfo &hi, UT_Vector3 &N);
    int                 sphere(const GU_Ray &, GU_RayInfo &hi, UT_Vector3 &N);
    int                 tube(const GU_Ray &, GU_RayInfo &hi, UT_Vector3 &N);

    void                minCircle(const UT_Vector3 &p, UT_Vector3 &minpt);
    void                minSphere(const UT_Vector3 &p, UT_Vector3 &minpt);
    void                minTube(const UT_Vector3 &p, UT_Vector3 &minpt);

    UT_Matrix4          xform;          // Ray transform
    UT_Matrix3          nmlXform;       // Normal transform
};

//________________________________________________________
//
//  Triangle ray intersection class
//________________________________________________________
//
class GU_API GU_RayTriangleInfo : public GU_RayPrimInfo
{
public:
             GU_RayTriangleInfo(const GEO_Primitive *prim,
                                 const GEO_Point *p0, const GEO_Point *p1,
                                 const GEO_Point *p2);
    virtual ~GU_RayTriangleInfo();

    virtual void        init();

    virtual int         intersect(const UT_Vector3 &org,
                                  const UT_Vector3 &dir,
                                  GU_RayInfo &hitinfo);
    virtual int         intersect(GU_RayPrimInfo *,GU_RayInfo &) { return -1; }
    virtual int         minimum(const UT_Vector3 &p, GU_MinInfo &mininfo);
    virtual int         minimum(GU_RayPrimInfo *prim, GU_MinInfo &mininfo);

public:
    const GEO_Point     *myV[3];        // Three corner vertices
    UT_Vector3           nml;           // Surface normal
    float                D;             // Plane eqn constant
    int                  x, y;          // Oriented to projected plane
};

// These are hardened triangles:
class GU_API GU_RayHTriangleInfo : public GU_RayPrimInfo
{
public:
             GU_RayHTriangleInfo(const GEO_Primitive *prim,
                                 const UT_Vector4 &p1, const UT_Vector4 &p2,
                                 const UT_Vector4 &p3);
    virtual ~GU_RayHTriangleInfo();

    virtual void        init();

    virtual int         intersect(const UT_Vector3 &org,
                                  const UT_Vector3 &dir,
                                  GU_RayInfo &hitinfo);
    virtual int         intersect(GU_RayPrimInfo *,GU_RayInfo &) { return -1; }
    virtual int         minimum(const UT_Vector3 &p, GU_MinInfo &mininfo);
    virtual int         minimum(GU_RayPrimInfo *prim, GU_MinInfo &mininfo);

public:
    UT_Vector3           myV[3];        // Three corner verices
    UT_Vector3           nml;           // Surface normal
    float                D;             // Plane eqn constant
    int                  x, y;          // Oriented to projected plane
};

//___________________________________________________________________________
//
//  Quad ray intersection classes - HQuad is for hardened points (i.e. NURBS)
//___________________________________________________________________________
//
class GU_API GU_RayQuadInfo : public GU_RayPrimInfo
{
public:
             GU_RayQuadInfo(const GEO_Primitive *prim,
                                 const GEO_Point *p0, const GEO_Point *p1,
                                 const GEO_Point *p2, const GEO_Point *p3,
                                 float ustart = 0.0F, float ulength = 1.0F,
                                 float vstart = 0.0F, float vlength = 1.0F);
    virtual ~GU_RayQuadInfo();

    virtual void        init();

    virtual int         intersect(const UT_Vector3 &org,
                                  const UT_Vector3 &dir,
                                  GU_RayInfo &hitinfo);
    virtual int         intersect(GU_RayPrimInfo *,GU_RayInfo &) { return -1; }
    virtual int         minimum(const UT_Vector3 &p, GU_MinInfo &mininfo);
    virtual int         minimum(GU_RayPrimInfo *prim, GU_MinInfo &mininfo);

public:
    const GEO_Point     *myV[4];        // Four corner vertices
    UT_Vector3           nml;           // Surface normal

    float                D;                     // Plane eqn constant
    int                  x, y;                  // Oriented to projected plane
    float                myUStart, myULength;
    float                myVStart, myVLength;
};

class GU_API GU_RayHQuadInfo : public GU_RayPrimInfo
{
public:
             GU_RayHQuadInfo(const GEO_Primitive *prim,
                                 const UT_Vector4 &p0, const UT_Vector4 &p1,
                                 const UT_Vector4 &p2, const UT_Vector4 &p3,
                                 float ustart = 0.0f, float ulen = 1.0f,
                                 float vstart = 0.0f, float vlen = 1.0f,
                                 int revnml = 0);
    virtual ~GU_RayHQuadInfo();

    virtual void        init();

    virtual int         intersect(const UT_Vector3 &org,
                                  const UT_Vector3 &dir,
                                  GU_RayInfo &hitinfo);
    virtual int         intersect(GU_RayPrimInfo *,GU_RayInfo &) { return -1; }
    virtual int         minimum(const UT_Vector3 &p, GU_MinInfo &mininfo);
    virtual int         minimum(GU_RayPrimInfo *prim, GU_MinInfo &mininfo);

public:
    UT_Vector3           myV[4];                // Four corner vertices
    UT_Vector3           nml;                   // Surface normal
    int                  myRevNml;      // Do we reverse the normal?

    // These numbers aren't needed by the bilinear code.
    //float              D;             // Plane eqn constant
    //int                x, y;          // Oriented to projected plane

    float                myUStart, myULength;
    float                myVStart, myVLength;
};

//________________________________________________________
//
//  General Face ray intersection class
//________________________________________________________
//
class GU_API GU_RayPolyInfo : public GU_RayPrimInfo
{
public:
             GU_RayPolyInfo(const GEO_Primitive *);
    virtual ~GU_RayPolyInfo();

    virtual int         intersect(const UT_Vector3 &org,
                                  const UT_Vector3 &dir,
                                  GU_RayInfo &hitinfo);
    virtual int         intersect(GU_RayPrimInfo *,GU_RayInfo &) { return -1; }
    virtual int         minimum(const UT_Vector3 &p, GU_MinInfo &mininfo);
    virtual int         minimum(GU_RayPrimInfo *prim, GU_MinInfo &mininfo);

public:
    UT_Vector3          nml;
    float               D;
    int                 x, y;
};

class GU_API GU_RayHPolyInfo : public GU_RayPrimInfo
{
public:
             GU_RayHPolyInfo(const GEO_Primitive *,
                                UT_Vector4Array &p);
    virtual ~GU_RayHPolyInfo();
    
    virtual int         intersect(const UT_Vector3 &org,
                                  const UT_Vector3 &dir,
                                  GU_RayInfo &hitinfo);
    virtual int         intersect(GU_RayPrimInfo *,GU_RayInfo &) { return -1; }
    virtual int         minimum(const UT_Vector3 &p, GU_MinInfo &mininfo);
    virtual int         minimum(GU_RayPrimInfo *prim, GU_MinInfo &mininfo);

public:
    int                  npts;
    float               *xval;
    float               *yval;
    UT_Vector3           nml;
    float                D;
    int                  x, y;
};

//________________________________________________________
//
//  Meta-surface ray intersection class
//________________________________________________________
//
class GU_API GU_RayMetaInfo : public GU_RayPrimInfo
{
public:
             GU_RayMetaInfo(TS_MetaExpression *expr);
    virtual ~GU_RayMetaInfo();

    virtual int         intersect(const UT_Vector3 &org,
                                  const UT_Vector3 &dir,
                                  GU_RayInfo &hitinfo);
    virtual int         intersect(GU_RayPrimInfo *,GU_RayInfo &) { return -1; }

public:
    TS_MetaExpression   *expr;
};


//________________________________________________________
//
//  Polyline intersection class
//________________________________________________________
//
class GU_API GU_RayPolyLineInfo : public GU_RayPrimInfo
{
public:
             GU_RayPolyLineInfo(const GEO_Primitive *, int span, int len);
    virtual ~GU_RayPolyLineInfo();

    virtual int         intersect(const UT_Vector3 &org, const UT_Vector3 &dir,
                                  GU_RayInfo &hitinfo);
    virtual int         intersect(GU_RayPrimInfo *prim,
                                  GU_RayInfo &hitInfo);
    virtual int         minimum(const UT_Vector3 &pt, GU_MinInfo &mininfo);
    virtual int         minimum(GU_RayPrimInfo *prim, GU_MinInfo &mininfo);

public:
    int                 mySpan;         // What part of the poly
    int                 myLen;          // we are responsible for
};

//________________________________________________________
//
//  Curve intersection class
//
//  Note: working in homogeneous coordinate
//________________________________________________________
//

class GU_API GU_RayCurveInfo : public GU_RayPrimInfo
{
public:
             GU_RayCurveInfo(const GEO_Primitive *curve)
                : GU_RayPrimInfo( curve ),
                myFirstSpanFlag(0), myLastSpanFlag(0) {}
    virtual ~GU_RayCurveInfo() {}

protected:
    // checks the proximity of the ray to the end points of the curve, 
    // and compares it with the tolerance given in hit_info,
    // but only for these endpoints
    // of the curve for which first/last span flags (the member data) are true.
    // If ray passes within the given tolerance, in the hemispherical cup
    // at the end of the curve, that "seals" the cylidrical zone around
    // the curve, it is considered as a hit, and 1 is returned.
    // INPUTS:
    //   org, dir - the origin and direction of the ray
    //   curve    - the curve endpoints we investigate
    //   hit_info - its tolerance is treated as a radius of a hemisphere at the 
    //              endpoints, within which to test the ray's presence
    // OUTPUT
    //   hit_info - if hit, a hit is added
    // RETURN:
    //  1 if hit: ray passes within tolerance radius of endpoint(s), otherwise 0
    int         intersectEndPointZone(const UT_Vector3 &org,
                                   const UT_Vector3 &dir,
                                   const GU_RayRBezCurve* curve,
                                   GU_RayInfo &hit_info) const;

public:
    // usually a curve primitive is subdivided into several spans, whose
    // info is encoded in GU_RayRBezCurveInfo and GU_RayNURBCurveInfo. 
    // Following flags indicate if this span is first or last on the curve.
    int                 myFirstSpanFlag : 1, // 1 if it's firsrt span on curve
                        myLastSpanFlag  : 1; // 1 if it's last span on curve
};

class GU_API GU_RayRBezCurveInfo : public GU_RayCurveInfo
{
public:
             GU_RayRBezCurveInfo(const GEO_Primitive *curve);
    virtual ~GU_RayRBezCurveInfo();

    virtual int         intersect(const UT_Vector3 &org,
                                  const UT_Vector3 &dir,
                                  GU_RayInfo &hitInfo);
    virtual int         intersect(GU_RayPrimInfo *prim,
                                  GU_RayInfo &hitInfo);
    virtual int         minimum(GU_RayPrimInfo *prim, GU_MinInfo &mininfo);
    virtual int         minimum(const UT_Vector3 &p, GU_MinInfo &mininfo);
    GU_RayRBezCurve    *buildCurve();
    
public:
    int                 mySpan;
    GU_RayRBezCurve    *myCurve;
};

class GU_API GU_RayNURBCurveInfo : public GU_RayCurveInfo
{
public:
             GU_RayNURBCurveInfo(const GEO_Primitive *curve);
    virtual ~GU_RayNURBCurveInfo();

    virtual int         intersect(const UT_Vector3 &org,
                                  const UT_Vector3 &dir,
                                  GU_RayInfo &hitInfo);
    virtual int         intersect(GU_RayPrimInfo *prim,
                                  GU_RayInfo &hitInfo);
    virtual int         minimum(GU_RayPrimInfo *prim, GU_MinInfo &mininfo);
    virtual int         minimum(const UT_Vector3 &p, GU_MinInfo &mininfo);
    
public:
    GU_RayRBezCurve     myCurve;
};


//________________________________________________________
//
//  Surface intersection class
//
//  Note: working in homogeneous coordinate
//________________________________________________________
//
class GU_API GU_RayRBezSurfInfo : public GU_RayPrimInfo
{
public:
             GU_RayRBezSurfInfo(const GEO_Primitive *surf);
    virtual ~GU_RayRBezSurfInfo();

    virtual int         intersect(const UT_Vector3 &org,
                                  const UT_Vector3 &dir,
                                  GU_RayInfo &hitInfo);
    virtual int         intersect(GU_RayPrimInfo *prim,
                                  GU_RayInfo &hitinfo);
    virtual int         minimum(const UT_Vector3 &p, GU_MinInfo &mininfo);
    virtual int         minimum(GU_RayPrimInfo *prim, GU_MinInfo &hitinfo);
    virtual GU_RayRBezSurf      *buildSurf();

public:
    int                          myUSpan, myVSpan;
    GU_RayRBezSurf              *mySurf;
};

class GU_API GU_RayNURBSurfInfo : public GU_RayPrimInfo
{
public:
             GU_RayNURBSurfInfo(const GEO_Primitive *surf);
    virtual ~GU_RayNURBSurfInfo();

    virtual int         intersect(const UT_Vector3 &org,
                                  const UT_Vector3 &dir,
                                  GU_RayInfo &hitInfo);
    virtual int         intersect(GU_RayPrimInfo *prim,
                                  GU_RayInfo &hitinfo);
    virtual int         minimum(const UT_Vector3 &p, GU_MinInfo &mininfo);
    virtual int         minimum(GU_RayPrimInfo *prim, GU_MinInfo &hitinfo);
public:
    GU_RayRBezSurf      mySurf;
};

//___________________________________________________________________________
//
//  Moving triangle ray intersection classes 
//      - HTriangle is for hardened points
//___________________________________________________________________________
//
class GU_API GU_RayMovingTriangleInfo : public GU_RayPrimInfo
{
public:
             GU_RayMovingTriangleInfo(const GEO_Primitive *prim0,
                                 const GEO_Point *p00, const GEO_Point *p01,
                                 const GEO_Point *p02,
                                 const GEO_Primitive *prim1,
                                 const GEO_Point *p10, const GEO_Point *p11,
                                 const GEO_Point *p12);
    virtual ~GU_RayMovingTriangleInfo();

    virtual void        init();

    virtual int         intersect(const UT_Vector3 &org,
                                  const UT_Vector3 &dir,
                                  GU_RayInfo &hitinfo);

private:
    int                 insertHit(const UT_Vector3 &org,
                                  const UT_Vector3 &dir,
                                  GU_RayInfo &hitinfo,
                                  float t, float nt);

public:
    const GEO_Point     *myV0[3];       // Three corner vertices at t = 0
    const GEO_Point     *myV1[3];       // Three corner vertices at t = 1

    double               a2, a1, a0;    // Coefficients of x comp of normal
    double               b2, b1, b0;    // Coefficients of y comp of normal
    double               c2, c1, c0;    // Coefficients of z comp of normal
};


#endif

---