SOP/SOP_Curve.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:
 *      George ElKoura
 *      Side Effects Software Inc.
 *      477 Richmon Street West
 *      Toronto, Ontario,  M5V 3E7
 *      Canada
 *      416-504-9876
 *
 * NAME:        SOP Library (C++)
 *
 * COMMENTS: The Curve sop generator.
 *
 */

#ifndef __SOP_Curve_h__
#define __SOP_Curve_h__

#include "SOP_API.h"
#include <math.h>
#include <PRM/PRM_Parm.h>
#include "SOP_Node.h"


#define   SC_CVS                0
#define   SC_BREAKPOINTS        1
#define   SC_FREEHANDDRAW       2

#define   SC_POLYGON            0
#define   SC_NURBS              1
#define   SC_BEZIER             2

#define   SC_STR_POINT              "%.6g,%.6g,%.6g "       // x,y,z
#define   SC_STR_WEIGHTED_POINT     "%.6g,%.6g,%.6g,%.6g "  // x,y,z,w
#define   SC_STR_RELATIVE_POINT     "@%.6g,%.6g,%.6g "      // @x,y,z
#define   SC_STR_REL_WEIGHTED_POINT "@%.6g,%.6g,%.6g,%.6g " // @x,y,z,w
#define   SC_STR_REF_POINT          "p%d "                  // pn
#define   SC_STR_COPY_POINT         "P%d "                  // Pn
#define   SC_STR_BREAKPOINT_U       "%db[%d] "              // xb[u]
#define   SC_STR_BREAKPOINT_UV      "%db[%d,%d] "           // xb[u,v]


class MSS_FaceState;

class SOP_API SOP_Curve : public SOP_Node
{

public:
    virtual unsigned     disableParms();
    virtual const char  *inputLabel(unsigned idx) const;
    virtual int          isRefInput(unsigned int i) const;

    static OP_Node      *myConstructor(OP_Network*, const char *, OP_Operator*);
    static PRM_Template  myTemplateList[];

    virtual int          getTranslateParmIndex();

    // given a number of vertices it calculates how many more are necessary
    // in order to have a valid gdp, taking into account the current
    // internal configuration of the SOP
    int         calcCVsNeeded(int numverts);

    void        COORDS(UT_String &str, float t) 
                                        { evalString(str, 2, 0, t); }

    void        SET_COORDS(UT_String &str, CH_StringMeaning meaning,
                           float t)
                                        { setString(str, meaning, 2, 0, t); }

    // SWITCHER
    int         TYPE(void)              { return evalInt(0, 0, 0); }
    void        SET_TYPE(int i, bool dflt = false)
                                        {
                                          setInt(0, 0, 0, i);
                                          if (dflt)
                                              getParm(0).overwriteDefaults(0);
                                        }

    int         METHOD(void)            { return evalInt(1, 0, 0); }
    void        SET_METHOD(int i, bool dflt = false)
                                        {
                                          setInt(1, 0, 0, i);
                                          if (dflt)
                                              getParm(1).overwriteDefaults(0);
                                        }

    int         CLOSED(void)            { return evalInt(4, 0, 0); }
    void        SET_CLOSED(int i, bool dflt = false)
                                        {
                                          setInt(4, 0, 0, i);
                                          if (dflt)
                                              getParm(4).overwriteDefaults(0);
                                        }

    // Curve properties options
    int         NORMBASIS(void)         { return evalInt(5, 0, 0); }

    int         ORDER(void)             { return evalInt(6, 0, 0); }
    void        SET_ORDER(int i)        { setInt(6, 0, 0, i); }

    int         PARMTYPE(void)          { return evalInt(7, 0, 0); }


    // Fitting options
    float       TOLERANCE(float t)      { return evalFloat(8, 0, t); }
    float       SMOOTH(float t)         { return evalFloat(9, 0, t); }
    int         SHARP(void)             { return evalInt(10, 0, 0); }

    int         KEEPINGEO(void)         { return evalInt(11, 0, 0); }

protected:
    SOP_Curve(OP_Network *net, const char *name, OP_Operator *entry);
    virtual ~SOP_Curve();

    virtual OP_ERROR             cookMySop(OP_Context &context);

private:
    // Returns the number of points parsed from the string
    int         parsePointList(const GU_Detail *ref_gdp,
                               UT_String &str, OP_Context &context);
    
    // Returns the number of CVs that are still needed 
    // i.e. minimum number - numverts
    int         calcCVsNeeded(int create_with_cvs, int face_type, int is_open,
                              int order, int numverts);

    UT_PtrArray<GEO_Point*>     myVertexList;
    UT_Vector4Array             myPointList;
    
    friend class sop_PointParser;
    friend class MSS_FaceState;
};

#endif

---