GEO/GEO_PrimMesh.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 class is a subclass of the GEO_Hull class.  It represents
 *      a linear patch (i.e. non-interpolating)
 *
 */

#ifndef __GEO_PrimMesh_h__
#define __GEO_PrimMesh_h__

#include "GEO_API.h"
#include "GEO_Hull.h"
#include "GEO_PrimType.h"

class GEO_API GEO_PrimMesh : public GEO_Hull {
public:
     GEO_PrimMesh(GEO_Detail *d) : GEO_Hull(d) { }
    ~GEO_PrimMesh();

    virtual unsigned    getPrimitiveId() const;

    // Compute the location of the breakpoint. Return 0 if OK, else -1.
    virtual int         evaluateBreakpoint(int uidx, int vidx,
                                           UT_Vector4 &pos,
                                           int du=0, int dv=0) const;

    // Evaluate the position or the derivative at unit domain point
    // (u,v), where u and v MUST be in [0,1]. Return 0 if OK and -1 otherwise.
    // The normal is not normalized.
    virtual bool         evaluatePoint( GEO_Vertex &result,
                                        GEO_AttributeHandleList &hlist,
                                        fpreal u, fpreal v,
                                        unsigned du=0, unsigned dv=0) 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;

    // Raise the number of CVs to match the newcount. The shape of the face
    // (especially if parametric) should NOT change. Return 0 upon success
    // and -1 otherwise.  start and stop define which indices to examine
    // if newcount is negative it is taken as a relative value.
    virtual int         loftU(int newcount, int start=-1, int stop=-1);
    virtual int         loftV(int newcount, int start=-1, int stop=-1);

    // Warp the mesh at u,v by the given delta. Change 1 or 4 Cvs and possibly
    // insert a knot once or more as well. If a knot is inserted or we happen
    // to land exactly on a knot, we change only one CV. The bias makes sense
    // only when changing 4 CVs, and will be ignored altogether if < 0.
    // We return the CV index in warpU/V and 0 in warp() if OK; -1 otherwise.
    virtual int          warpU(float u, const UT_Vector3 &delta,
                               GEO_AttributeHandleList &hlist,
                               float sharpness = 0.0f, float bias = -1.0f);
    virtual int          warpV(float v, const UT_Vector3 &delta,
                               GEO_AttributeHandleList &hlist,
                               float sharpness = 0.0f, float bias = -1.0f);
    virtual int          warp (float u, float v, const UT_Vector3 &delta,
                               GEO_AttributeHandleList &hlist,
                               float usharpness = 0.f, float vsharpness = 0.f,
                               float ubias = -1.0f, float vbias = -1.0f);
    virtual int          warpU(float u, const UT_Vector3 &delta,
                               GB_FloatOffsets *foffsets = 0,
                               float sharpness = 0.0f, float bias = -1.0f);
    virtual int          warpV(float v, const UT_Vector3 &delta,
                               GB_FloatOffsets *foffsets = 0,
                               float sharpness = 0.0f, float bias = -1.0f);
    virtual int          warp (float u, float v, const UT_Vector3 &delta,
                               GB_FloatOffsets *foffsets = 0,
                               float usharpness = 0.f, float vsharpness = 0.f,
                               float ubias = -1.0f, float vbias = -1.0f);

    // Append another hull to us in one of two ways: blend the two endpoints
    // or connect them straight or rounded. The bias ranges from 0 to 1 and is
    // relevant only to blending. The tolerance for blending: if 0, the two
    // endpoints will merge into one point with a discontinuity; if less than
    // 1, we insert knots into the hulls to minimize the affected areas; if 1,
    // no refinement is done. For the non-blend case, the tolerance will
    // generate a span whose shape goes from round to straight; 0 tolerance
    // means straight connection. If unrefine is on, we'll try to reduce the
    // complexity of the hull if we're connecting rounded. We return 0 if OK
    // and -1 if error. Both hulls must be open and have the same order.
    virtual int         attachU(const GEO_Hull &hull, int blend = 1,
                                float bias = 0.5f, float tolerance = 1.0f,
                                int= 1,GB_PointGroup *ptgroup=0);
    virtual int         attachV(const GEO_Hull &hull, int blend = 1,
                                float bias = 0.5f, float tolerance = 1.0f,
                                int= 1,GB_PointGroup *ptgroup=0);

    // Refine for all spans with specified number of divisions per span.
    virtual void        spanRefineU(GEO_AttributeHandleList &hlist,
                                    int numdivs=1);
    virtual void        spanRefineU(int numdivs=1);
    virtual void        spanRefineUWAttrib(const GB_FloatOffsets &offsets,
                                           int numdivs = 1);
    virtual void        spanRefineV(GEO_AttributeHandleList &hlist,
                                    int numdivs=1);
    virtual void        spanRefineV(int numdivs=1);
    virtual void        spanRefineVWAttrib(const GB_FloatOffsets &offsets,
                                           int numdivs = 1);

    virtual int         unrollU(int append_pts = 1);
    virtual int         unrollV(int append_pts = 1);

protected:
    virtual int         savePrivate(ostream &, int binary) const;
    virtual bool        loadPrivate(UT_IStream &);
    virtual int         saveExtra  (ostream &, int binary) const;
    virtual bool        loadExtra  (UT_IStream &);

    // Check the validity of the data. Meant to be called especially at loading
    // time. The method returns 1 if OK and 0 if trouble.
    virtual bool        validate(void) const;

    // Return the squared max distance between any two successive vertices
    // and the index of the "left" vertex. If the polygon is closed we
    // compare the 1st and last vertices as well and if their distance is the
    // largest, we return the index of the last vertex.
    int                 findMaxDistanceU(float &maxdist2, 
                                         int start, int stop) const;

    int                 findMaxDistanceV(float &maxdist2, 
                                         int start, int stop) const;

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

---