GEO/GEO_Quadric.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 Software Inc.
 *      20 Maud St.
 *      Toronto, Ontario,  M5V 2M5
 *      Canada
 *      416-366-4607
 *
 * NAME:        Geometry Library (C++)
 *
 * COMMENTS:
 *      This is the base class for Quadratics (Sphere, Tube, Cone, Blob, etc.)
 *      Since these quadrics may have any rotation, there are axes kept
 *      for the orientation.  These axes are maintained by the base class.
 *      This class doesn't really mean quadric/quadratic functions. In practice,
 *      it has come to mean "this primitive has a transform."
 *
 */

#ifndef __GEO_Quadric_H__
#define __GEO_Quadric_H__

#include "GEO_API.h"
#include <UT/UT_Matrix3.h>
#include "GEO_Primitive.h"
#include "GEO_Vertex.h"

class   UT_Matrix4;
class   GEO_Point;
class   GEO_Detail;

// For the for loop, we can use getFastVertex since we know the index is valid

class GEO_API GEO_Quadric : public GEO_Primitive
{
public:
              GEO_Quadric(GEO_Detail *d);
     virtual ~GEO_Quadric();

//
//  Methods common to all primitives.
    virtual unsigned             getPrimitiveId() const = 0;
    virtual int                  getBBox(UT_BoundingBox *bbox) const = 0;
    virtual UT_Vector3           baryCenter() const;
    virtual UT_Vector3           computeNormal() const;
    virtual int                  save(ostream &os, int binary) const;
    virtual bool                 load(UT_IStream &is);

    // Transforms the matrix associated with this primitive.  The
    // translate component is ignored: Translate the vertices of
    // the primitive to translate the primitive.
    // This only works with quadrics (sphere, tube, metaballs) and volumes.
    virtual void                 transform(const UT_Matrix4 &mat);

    virtual void                 untransform(void);
    virtual GEO_Primitive       *copy(int preserve_shared_pts = 0) const;
    virtual void        copyPrimitive(const GEO_Primitive *src, 
                                GEO_Point **ptredirect);
    virtual void        addPointRefToGroup(GB_PointGroup &grp) const;

    void                changePointRef(GB_Element *from, GB_Element *to);
    virtual int         vertexApply(int (*a)(GB_Vertex &, void *), void *);
    virtual int         vertexApply(int (*a)(const GB_Vertex &, void *),
                                    void *) const;
    virtual void        reverse(void); 

    virtual unsigned             getVertexCount() const;
    virtual const GEO_Vertex    &getVertex(unsigned idx = 0) const;
    virtual GEO_Vertex          &getVertex(unsigned idx = 0);

    // Take the whole set of points into consideration when applying the
    // point removal operation to this primitive. The method returns 0 if
    // successful, -1 if it failed because it would have become degenerate,
    // and -2 if it failed because it would have had to remove the primitive
    // altogether.
    virtual int          detachPoints (GB_PointGroup &grp);

    virtual int          isDegenerate() const;

#if 0
    virtual bool         evaluatePoint(GEO_Vertex &handle,
                                GEO_AttributeHandleList &hlist,
                                fpreal u, fpreal v, uint du, uint dv) const;
    virtual int          evaluatePoint(UT_Vector4 &pos, float u, float v,
                                        uint du, uint dv) const;
#endif
//
//  Methods to set the space of a primitive
    void                getAxes(UT_Vector3 &x, UT_Vector3 &y,
                                UT_Vector3 &z) const;
    void                getXAxis(UT_Vector3 &x) const;
    void                getYAxis(UT_Vector3 &y) const;
    void                getZAxis(UT_Vector3 &z) const;

    void                setAxes(const UT_Vector3 &x, const UT_Vector3 &y,
                                const UT_Vector3 &z);
    void                setXAxis(const UT_Vector3 &x);
    void                setYAxis(const UT_Vector3 &y);
    void                setZAxis(const UT_Vector3 &z);

    const UT_Matrix3    &getTransform(void) const { return myXform; }
    void                 setTransform(const UT_Matrix3 &m) { myXform = m; }

    void                 getTransform4(      UT_Matrix4 &matx) const;
    void                 setTransform4(const UT_Matrix4 &matx);

    void                 setVertex(GEO_Point *ppt)
                         {
                             myVertex.setPt(ppt);
                         }

    // Have we been deactivated and stashed?
    virtual              void   stashed(int onoff);

    // Map the normalized length (distance value [0,1]) parameter to the unit 
    // parameterization of the primitve
    virtual void         unitLengthToUnitPair(float  ulength, float  vlength,
                                              float &uparm,  float &vparm)const;

    virtual void         unitToUnitLengthPair(float  uparm,   float  vparm,
                                              float &ulength, float &vlength)
                                                                        const;

    // Is this primitive a GEO_Quadric?
    virtual bool         isQuadric() const { return true; }

protected:
    // Methods for finding out about point references
    virtual void        copyOffsetPrimitive(const GEO_Primitive *src,
                                            int basept);
    virtual int         savePrivate(ostream &os, int binary) const;
    virtual bool        loadPrivate(UT_IStream &is);
    virtual int         pointCanDelete(GB_Element *) const;
    virtual void        pointDeleted(GB_Element *pt);
    virtual int         isPointUsed(GB_Element *pt) const;
    virtual int         isPointGroupUsed(const GB_PointGroup &grp) const;

private:
    GEO_Vertex          myVertex;       // My vertex
    UT_Matrix3          myXform;        // My transform

    friend ostream      &operator<<(ostream &os, const GEO_Quadric &d)
                        {
                            d.save(os, 0);
                            return os;
                        }
    char                myStashedState;
};

#endif

---