UT/UT_CoordSpace.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 system of coordinates.
 *
 */

#ifndef __UT_CoordSpace_h__
#define __UT_CoordSpace_h__

#include "UT_API.h"
#include "UT_Plane.h"

class UT_Matrix3;
class UT_XformOrder;

class UT_API UT_CoordSpace : public UT_Plane
{
public:
    // Several constructors that define a plane as (X - thePoint)*theNormal = 0
    UT_CoordSpace(UT_Plane::UT_PlaneType p = UT_Plane::UT_PLANE_XY);
    UT_CoordSpace(const UT_Vector3 &point, const UT_Vector3 &axaxis,
                  const UT_Vector3 &ayaxis, const UT_Vector3 *azaxis,
                  int norm=1);
    UT_CoordSpace(const UT_Vector3 &p0, const UT_Vector3 &p1, 
                  const UT_Vector3 &p2);
    UT_CoordSpace(const UT_CoordSpace &p);

    virtual ~UT_CoordSpace(void);

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

    // Orient one axis and rotate the others accordingly, or set them all:
    void                 xaxis(const UT_Vector3 &x,   int norm = 1);
    void                 yaxis(const UT_Vector3 &y,   int norm = 1);
    void                 zaxis(const UT_Vector3 &z,   int norm = 1);
    void                 setAxes(const UT_Vector3 &x, const UT_Vector3 &y,
                                 const UT_Vector3 &z, int norm = 1);

    // Query the axes:
          UT_Vector3    &xaxis(void)            { return theXAxis; }
    const UT_Vector3    &xaxis(void) const      { return theXAxis; }
          UT_Vector3    &yaxis(void)            { return theYAxis; }
    const UT_Vector3    &yaxis(void) const      { return theYAxis; }
          UT_Vector3    &zaxis(void)            { return normal(); }
    const UT_Vector3    &zaxis(void) const      { return normal(); }

    // Set or query the origin:
          void           origin(const UT_Vector3 &o) { point() = o; }
          UT_Vector3    &origin(void)           { return point(); }
    const UT_Vector3    &origin(void) const     { return point(); }


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

    // Assume we're given a rotation matrix
    // Rotate about our own origin.
    void                 rotate(const UT_Matrix3 &rotmatx);

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

    void                 getTransformMatrix(UT_Matrix4 &matx) const;

    // Compute rotation from world space to us or vice-versa.
    // Return the same value "crack()" does.
    int                  fromWorldRotation(float &rx, float &ry, float &rz,
                                           const UT_XformOrder &order) const;
    int                    toWorldRotation(float &rx, float &ry, float &rz,
                                           const UT_XformOrder &order) const;

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

    
    const char          *className() const;
    
    void                 convertToWorld( UT_Vector3 &rel ) const
        {
            UT_Vector3 r;
            r.x() = rel.x()*xaxis().x()+rel.y()*yaxis().x()+rel.z()*zaxis().x();
            r.y() = rel.x()*xaxis().y()+rel.y()*yaxis().y()+rel.z()*zaxis().y();
            r.z() = rel.x()*xaxis().z()+rel.y()*yaxis().z()+rel.z()*zaxis().z();
            r    += origin();
            rel   = r;
        }
    void                 convertToWorldNoOriginAdj( UT_Vector3 &rel ) const
        {
            UT_Vector3 r;
            r.x() = rel.x()*xaxis().x()+rel.y()*yaxis().x()+rel.z()*zaxis().x();
            r.y() = rel.x()*xaxis().y()+rel.y()*yaxis().y()+rel.z()*zaxis().y();
            r.z() = rel.x()*xaxis().z()+rel.y()*yaxis().z()+rel.z()*zaxis().z();
            rel   = r;
        }

protected:
private:
    // Define the two other axes
    UT_Vector3  theXAxis;
    UT_Vector3  theYAxis;
};

#endif

---