GU/GU_PolyWire.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:
 *      Jeff Lait
 *      Side Effects Software Inc
 *      477 Richmond Street West
 *      Toronto, Ontario
 *      Canada   M5V 3E7
 *      416-504-9876
 *
 * NAME:        GU_PolyWire.h ( GU Library, C++)
 *
 * COMMENTS: This constructs a series of wires for each edge
 *      of a polygon group.
 */

#ifndef __GU_PolyWire__
#define __GU_PolyWire__

#include "GU_API.h"
#include <UT/UT_RefArray.h>
#include <UT/UT_Vector3Array.h>

class GU_Detail;
class GB_PrimitiveGroup;
class gu_ConnectionGraph;
class GEO_Point;
class UT_HashTable;
class gu_EdgeHashEntry;

class GU_API gu_JunctionPoint
{
public:
    GEO_Point   *pt;
    UT_Vector3   pos;
    float        scaletotal;    // Total scale factors
    int          numpts;        // Number of points who've grabbed this.
};

class GU_API GU_PolyWire
{
public:
    GU_PolyWire();
    virtual ~GU_PolyWire();

    // This does NOT claim ownership of these:
    void                 setPtWidths(float *widths) { myPtWidths = widths; }
    void                 setJointScale(float *scale) { myJointScale = scale; }
    void                 setPtSmooth(int *smooth) { myPtSmooth = smooth; }
    // Parameter Setting:
    void                 setDivisions(int *div);
    void                 setSegments(const GEO_Point *pt1, 
                                    const GEO_Point *pt2, int segments);
    void                 setV(const GEO_Point *pt1, const GEO_Point *pt2,
                                float v1, float v2);
    void                 setU(const GEO_Point *pt1, const GEO_Point *pt2,
                                float uoff, float u1, float u2);
    void                 setSegScales(const GEO_Point *pt1, 
                                const GEO_Point *pt2, float segscale1, 
                                float segscale2);
        
    void                 setGdp(GU_Detail *gdp) { myGdp = gdp; }
    void                 setGrp(GB_PrimitiveGroup *grp) { myPrimGroup = grp; }
    void                 setJointCorrection(int jc) { myJointCorrection = jc; }
    void                 setDoTextures(int dotext) { myDoTextures = dotext; }
    void                 setUseUpVector(int up) { myUseUpVector = up; }
    void                 setUpVectors(UT_Vector3 *up) { myUpVectors = up; }

    // Parameter access functions:
    GU_Detail           *getGdp() const { return myGdp; }
    int                  getSmooth(int pt) const { return myPtSmooth[pt]; }
    float                getWidth(int pt) const { return myPtWidths[pt]; }
    float                getMaxScale(int pt) const { return myJointScale[pt]; }
    int                  getSegments(int pt1, int pt2) const;
    void                 getV(int pt1, int pt2, float &v1, float &v2) const;
    void                 getU(int pt1, int pt2, float &uoff, float &u1, 
                                float &u2) const;
    void                 getSegScales(int pt1, int pt2, float &segscale1,
                                    float &segscale2) const;
    int                  getDivisions(int pt) const { return myDivs[pt]; }
    UT_Vector3           getUpVector(int pt) const { return myUpVectors[pt]; }
    int                  doJointCorrection() const { return myJointCorrection; }
    int                  doTextures() const { return myDoTextures; }
    int                  useUpVector() const { return myUseUpVector; }

    // Deal with the texture value cache:
    float                getPtTexU(int idx);
    void                 setPtTexU(int idx, float val);
    float                getPtTexV(int idx);
    void                 setPtTexV(int idx, float val);
    float                getGlbPtTexU(int idx);
    int                  hasGlbPtTexU(int idx) const;
    void                 setGlbPtTexU(int idx, float val);

    // This uses the built-in circle caches to get the position
    // on the x/y circle of the required point...
    // Valid numbers are from 0..(myDiv-1)
    UT_Vector3           getCirclePos(int idx, int div) 
                        { buildCircleCache(div);
                          return (*myCircleCache(div))(idx); }

    // Builds all the wires:
    void                 buildWire();

    GEO_Point           *getJunctionPoint(const UT_Vector3 &stdpos,
                            const UT_Vector3 &center, float scale);
    // Calculates realworld coordinates of the point
    void                 evaluateJunctionPoints(const UT_Vector3 &center,
                            float scale, GEO_Point *cpt);
    void                 clearJunctionPoints();

    // Go through a poly list and texture clamp all the polys...
    void                 textureClampPolys(const UT_PtrArray<GEO_PrimPoly *> 
                                            &polylist, 
                                            float ubase, float uwidth);
        
    
protected:
    void                 buildCircleCache(int div);

    // These are effectively attributes, but a bit cheaper.
    // Widths is the radius of the wires at each point, smooth
    // is a boolean value of whether to do smooth joining or just
    // connect them.
    // Segs and divs are how to split up tubes that enter this point.
    float               *myPtWidths;
    float               *myJointScale;
    int                 *myPtSmooth;
    int                 *myDivs;
    UT_Vector3          *myUpVectors;
    int                  myJointCorrection;
    int                  myDoTextures;
    int                  myUseUpVector;
    // For each point, what it's "u" value is.
    UT_FloatArray        myTexU;
    UT_FloatArray        myTexV;
    // These ones are fixed!
    UT_FloatArray        myGlbTexU;

    // Cached circle poses cause I really hate sins and coses...
    // You might argue that the cost of sin & cos is buried by the
    // creation of and interpolation of points and attributes.  You
    // might even be right.
    UT_PtrArray<UT_Vector3Array *>      myCircleCache;

    // What to act on:
    GU_Detail           *myGdp;
    GB_PrimitiveGroup   *myPrimGroup;

    // Our connection graph:
    gu_ConnectionGraph  *myGraph;

    // Our edge hash tabel:
    UT_HashTable                *myEdgeHash;

    // Our junction point list:
    UT_RefArray<gu_JunctionPoint>       myJunctionPoints;

    // Our hash table values:
    UT_PtrArray<gu_EdgeHashEntry *>     myEdgeHashEntries;
};

#endif

---