GEO/GEO_PrimTube.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 a cylinder.  There are two ways of storing a cylinder/tube:
 *      a) By setting two point references for the base and top
 *              of the cylinder.  In this method, the height of the
 *              cylinder is locked.  As well, the axes are fixed.
 *              This is the least preferred method since the X and Y
 *              axes are undefined (too many degrees of freedom).
 *      b) The preferred way is to specify a single point.  The tube
 *              will extend in the Z axis according to the height
 *              specified.  The tube may then be rotated or whatever
 *              and the X and Y axes will always be well defined.
 *
 */

#ifndef __GEO_PrimTube_H__
#define __GEO_PrimTube_H__

#include "GEO_API.h"
#include "GEO_Quadric.h"
#include "GEO_PrimType.h"
#include "GEO_Vertex.h"

#define GEO_TUBE_XSECT_TOP_XP    0
#define GEO_TUBE_XSECT_TOP_XN    1
#define GEO_TUBE_XSECT_TOP_ZP    2
#define GEO_TUBE_XSECT_TOP_ZN    3
#define GEO_TUBE_XSECT_TOP_CTR   4
#define GEO_TUBE_XSECT_BOT_XP    5
#define GEO_TUBE_XSECT_BOT_XN    6
#define GEO_TUBE_XSECT_BOT_ZP    7
#define GEO_TUBE_XSECT_BOT_ZN    8
#define GEO_TUBE_XSECT_BOT_CTR   9
#define GEO_TUBE_XSECT_MID_XP   10
#define GEO_TUBE_XSECT_MID_XN   11
#define GEO_TUBE_XSECT_MID_ZP   12
#define GEO_TUBE_XSECT_MID_ZN   13

#define GEO_TUBE_GUIDEEDGE_BX    0
#define GEO_TUBE_GUIDEEDGE_BZ    1
#define GEO_TUBE_GUIDEEDGE_MX    2
#define GEO_TUBE_GUIDEEDGE_MZ    3
#define GEO_TUBE_GUIDEEDGE_TX    4
#define GEO_TUBE_GUIDEEDGE_TZ    5
#define GEO_TUBE_GUIDEEDGE_XN    6
#define GEO_TUBE_GUIDEEDGE_XP    7
#define GEO_TUBE_GUIDEEDGE_ZN    8
#define GEO_TUBE_GUIDEEDGE_ZP    9

//
// indices for tube capture region attributes (GB_ATR_FLOAT)
//
enum GEO_TubeCaptureAtrFields {
    I_GEO_TUBECAPTURE_BCAP=0,           // bottom cap height
    I_GEO_TUBECAPTURE_TCAP,             // top cap height
    I_GEO_TUBECAPTURE_TAPERX,           // taper factor in tube's local X
    I_GEO_TUBECAPTURE_TAPERZ,           // taper factor in tube's local X
    I_GEO_TUBECAPTURE_INWEIGHT,         // max weight at region center
    I_GEO_TUBECAPTURE_OUTWEIGHT,        // min weight at region edge
    GEO_TUBECAPTURE_ATTRIB_SZ           // this one should always be last
};

class GEO_API GEO_PrimTubeFlags {
public:
        GEO_PrimTubeFlags()
        {
            endcaps     = 0;
        }
        unsigned        endcaps:1;      // Tube has end caps
};

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

    virtual unsigned             getPrimitiveId() const;

    // Evaluate the position or the derivative at domain point (u,v), where
    // u and v MUST be in [0,1]. "v" and "dv" will be ignored when dealing
    // with one-dimensional types such as circles and polygons. Return 0 if
    // OK and -1 otherwise.
    virtual bool         evaluatePoint( GEO_Vertex &result,
                                GEO_AttributeHandleList &hlist,
                                fpreal u, fpreal v, uint du, uint dv) const;
    virtual int          evaluatePoint( UT_Vector4 &pos, float u, float v = 0,
                                        unsigned du=0, unsigned dv=0) const;
    virtual int          evaluatePointWAttrib(UT_Vector4 &pos,
                                        GB_AttributeData &adata,
                                        const GB_FloatOffsets &foffsets,
                                        float u, float v = 0, unsigned du = 0,
                                        unsigned dv = 0) const;

    virtual int                  getBBox(UT_BoundingBox *bbox) const;
    virtual void                 addToBSphere(UT_BoundingSphere *bsphere) const;
    // virtual UT_Vector3                baryCenter() const;
    virtual GEO_Primitive       *copy(int preserve_shared_pts = 0) const;
    virtual void                 copyPrimitive(const GEO_Primitive *src,
                                    GEO_Point **ptredirect);

    virtual int          hasGuideEdge(int edgeid, UT_Vector4 &a, 
                                                 UT_Vector4 &b) const;
    virtual int          hasXsectPoint(int pointid, UT_Vector4 &p) const;

//
//  End cap handling for tube primitive
    unsigned             endcaps(void) const { return flags.endcaps; }
    void                 setEndCaps(int onOff) { flags.endcaps = onOff; }
    float                getTaper(void) const { return myTaper; }
    void                 setTaper(float t) { myTaper = t; }

//
//  Tube Capture Region handling
//

//  computes weight of point in this capture region tube.  If the point
//  is outside the region, the weight is zero.  Otherwise the weight is
//  .0 at the edge of the region, 1.0 along the center bone line of the
//  region.   
//  pos must be in tube's SOP space, i.e. you've multiplied by the 
//  inverse of getTransform4()
    float                getCaptureRegionWeight( const UT_Vector3 &pos,
                                         int   tubeCaptAtrOffset ) const;
    static float         computeCaptureRegionWeight( const UT_Vector3 &pos,
                                         float bcap, float tcap, float taperx,
                                         float taperz, float min_weight,
                                         float max_weight );

    virtual float        calcVolume(UT_Vector3 &refpt) const;
    virtual float        calcArea() const;
    virtual float        calcPerimeter() const;
protected:
    virtual void         copyOffsetPrimitive(const GEO_Primitive *src,
                                                int basept);
    // Save and load the privates of this class.
    virtual int          savePrivate(ostream &os, int binary) const;
    virtual bool         loadPrivate(UT_IStream &is);

private:
    GEO_PrimTubeFlags    flags;
    // The taper is the radius of the bottom half of the default tube.
    // The top half's radius is one.  These radii are then modified by
    // myXform.
    float                myTaper;

    friend ostream      &operator<<(ostream &os, const GEO_PrimTube &d)
                        {
                            d.save(os, 0);
                            return os;
                        }
};
#endif

---