UT/UT_Plane.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:
 *      Cristin Barghiel
 *      Side Effects Software Inc.
 *      20 Maud St.
 *      Toronto, Ontario,  M5V 2M5
 *      Canada
 *      416-366-4607
 *
 * NAME:        Utility Library (C++)
 *
 * COMMENTS:
 *      A 3D plane.
 *
 */

#ifndef __UT_Plane_h__
#define __UT_Plane_h__

#include "UT_API.h"
#include <iostream.h>
#include "UT_Vector3.h"

class UT_Matrix3;
class UT_DMatrix4;

class UT_API UT_Plane {
public:
    // The 3 classic types of planes. Evidently, a UT_Plane object can be
    // an arbitrary plane, but it helps to have some defaults.
    enum UT_PlaneType { UT_PLANE_XY, UT_PLANE_YZ, UT_PLANE_XZ };

    // Several constructors that define a plane as (X - thePoint)*theNormal = 0
    UT_Plane(UT_PlaneType p=UT_PLANE_XY);
    UT_Plane(const UT_Vector3 &apoint, const UT_Vector3 &nmlVec, int norm=1);
    UT_Plane(const UT_Vector3 &p0, const UT_Vector3 &p1, const UT_Vector3 &p2);
    UT_Plane(const UT_Vector4 &p);
    UT_Plane(const UT_Plane &p);

    virtual ~UT_Plane(void);

    // Intersect a line defined parametrically as 'p + t*v' with this plane.
    // If the line runs parallel to the plane, both methods return FLT_MAX
    // as the intersection point. The second method also returns -1; if not
    // parallel, it returns 0.
    UT_Vector3   intersect(const UT_Vector3 &p, const UT_Vector3 &v) const;
    int          intersectLine(const UT_Vector3 &p, const UT_Vector3 &v, 
                               UT_Vector3 &hit) const;
    int          intersectRay(const UT_Vector3 &p, const UT_Vector3 &v, 
                              UT_Vector3 &hit) const;

    // We occasionally need to find the intersection of a line with this
    // plane shifted to another position (ie. thePoint changes but theNormal
    // doesn't). offsetPt is a point on the shifted plane.
    int          intersectLine(const UT_Vector3 &offsetPt,
                               const UT_Vector3 &p, const UT_Vector3 &v,
                               UT_Vector3 &hit) const;
    int          intersectRay(const UT_Vector3 &offsetPt,
                              const UT_Vector3 &p, const UT_Vector3 &v,
                              UT_Vector3 &hit) const;

    // Find the projection of point p on the plane. The second method
    // returns the signed distance to the plane.
    UT_Vector3   project(const UT_Vector3 &p) const;
    fpreal       project(const UT_Vector3 &p, UT_Vector3 &projection) const;

    // Find the point symmetric to p and store it in p:
    void         symmetry(UT_Vector3 &p);

    // Find out if the plane contains the point p and return true or false.
    int          contains(const UT_Vector3 &p) const;

    // Finds if the given point is on one side or the other.  The side
    // in direction of the normal is 1, the other is 0.
    int          side(const UT_Vector3 &p) const;

    // Query the point and the normal;
          UT_Vector3    &point(void)            { return thePoint; }
    const UT_Vector3    &point(void) const      { return thePoint; }
          UT_Vector3    &normal(void)           { return theNormal; }
    const UT_Vector3    &normal(void) const     { return theNormal; }

    // Flip by 180 degrees:
    virtual void         negate(void);

    // Rotate by a given angle, expressed in radians:
    virtual void         rotate(UT_Vector3  &axis,   fpreal theta, int norm=1);
    virtual void         rotate(UT_Axis3::axis a, fpreal theta);

    // Apply an invertible transformation to the plane: the method that takes
    // a non-const matrix returns the inverted and transposed matrix.
    virtual void         transform(const UT_Matrix4 &matx);
    virtual void         transform(      UT_Matrix4 &matx);
    virtual void         transform(const UT_DMatrix4 &matx);
    virtual void         transform(      UT_DMatrix4 &matx);

    // Load ourselves from another plane:
    UT_Plane            &operator=(const UT_Plane &p)
                         {
                             if (this != &p)
                             {
                                 thePoint  = p.thePoint;
                                 theNormal = p.theNormal;
                             }
                             return *this;
                         }

    // Translate the plane along the normal by the given factor.
    void                 shiftOffset(fpreal byFactor)
                         {
                             thePoint += (theNormal * byFactor);
                         }


    virtual const char  *className() const;

protected:
private:
    // The defining point and normal:
    UT_Vector3  thePoint;
    UT_Vector3  theNormal;
};

#endif

---