SOP/SOP_UVTransform.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:
 *      Jonathan McGee
 *      Side Effects Software Inc.
 *      477 Richmond Street West
 *      Toronto, Ontario,  M5V 3E7
 *      Canada
 *      416-504-9876
 *
 * NAME:        SOP Library (C++)
 *
 * COMMENTS: The UV Transform SOP
 *        
 *           Note: This is the first example of a SOP which uses
 *           the GDT functionality as a means towards optimal
 *           interactive performance.  Notice how it does not
 *           use the "beginNewOperation" functionality
 *           of SOP_GDT.  However, SOP_GDT provides facilities
 *           for restoring the input geometry extremely quickly.
 *
 *           IMPORTANT: Any changes made to this SOP will probably
 *           need to be made to SOP_UVEdit, and vice versa!!!
 *
 */

#ifndef __SOP_UVTransform_h__
#define __SOP_UVTransform_h__

#include "SOP_API.h"
#include "SOP_GDT.h"
#include <GEO/GEO_SoftTransformCache.h>

class PRM_MenuEntry;

enum {
    // Group parameters
    SOP_UVTRANSFORM_GRP_IDX = SOP_GDT_GRP_IDX,
    SOP_UVTRANSFORM_GRPTYPE_IDX,

    // Transform parameters
    SOP_UVTRANSFORM_TRS_IDX,
    SOP_UVTRANSFORM_XYZ_IDX,
    SOP_UVTRANSFORM_T_IDX,
    SOP_UVTRANSFORM_R_IDX,
    SOP_UVTRANSFORM_S_IDX,
    SOP_UVTRANSFORM_SHEAR_IDX,
    SOP_UVTRANSFORM_P_IDX,

    // Soft Parameters
    SOP_UVTRANSFORM_RADIUS_IDX,
    SOP_UVTRANSFORM_SOFTTYPE_IDX,
    SOP_UVTRANSFORM_TANGENT_IDX,
    SOP_UVTRANSFORM_KERNEL_IDX,
    SOP_UVTRANSFORM_METRIC_IDX,
    SOP_UVTRANSFORM_GLOBAL_IDX,
    SOP_UVTRANSFORM_UVGLOBAL_IDX
};

class SOP_API SOP_UVTransform : public SOP_GDT
{
public:
             SOP_UVTransform(OP_Network *net, const char *name,
                             OP_Operator *entry);
    virtual ~SOP_UVTransform();

    virtual unsigned             disableParms();

    static OP_Node              *myConstructor(OP_Network *net,
                                               const char *name,
                                               OP_Operator *entry);

    static PRM_Template          myTemplateList[];
    static PRM_Template          myObsoleteList[];
    static CH_LocalVariable      myVariables[];

    virtual float                getVariableValue(int index, int thread);
    virtual OP_ERROR             cookInputGroups(OP_Context &context,
                                                 int alone = 0);

    virtual void                 resolveObsoleteParms(
                                                PRM_ParmList *obsolete_parms);

protected:
    virtual OP_ERROR             cookMySop(OP_Context &context);
    virtual const char          *inputLabel(unsigned idx) const;

    virtual bool                 getGroupCentroid(OP_Context &context,
                                                  UT_Vector3 &centroid);

    virtual void                 getXformOrder(UT_XformOrder &xord, 
                                                CH_Channel *chp);


#ifdef INTEL_COMPILER
private:                                        
        SOP_UVTransform(const SOP_UVTransform& ) : SOP_GDT(NULL, NULL, NULL) { }
#endif                                  
private:
    // Selection
    int          GRPTYPE()      { return evalInt(SOP_UVTRANSFORM_GRPTYPE_IDX,
                                                0, 0); }

    // Transform
    int          TRS()          { return evalInt(SOP_UVTRANSFORM_TRS_IDX,
                                                0, 0); }
    int          XYZ()          { return evalInt(SOP_UVTRANSFORM_XYZ_IDX,
                                                0, 0); }
    float        TX(float t)    { return evalFloat(SOP_UVTRANSFORM_T_IDX,
                                                0, t); }
    float        TY(float t)    { return evalFloat(SOP_UVTRANSFORM_T_IDX,
                                                1, t); }
    float        TZ(float t)    { return evalFloat(SOP_UVTRANSFORM_T_IDX,
                                                2, t); }
    float        RX(float t)    { return evalFloat(SOP_UVTRANSFORM_R_IDX,
                                                0, t); }
    float        RY(float t)    { return evalFloat(SOP_UVTRANSFORM_R_IDX,
                                                1, t); }
    float        RZ(float t)    { return evalFloat(SOP_UVTRANSFORM_R_IDX,       
                                                2, t); }
    float        SX(float t)    { return evalFloat(SOP_UVTRANSFORM_S_IDX,
                                                0, t); }
    float        SY(float t)    { return evalFloat(SOP_UVTRANSFORM_S_IDX,
                                                1, t); }
    float        SZ(float t)    { return evalFloat(SOP_UVTRANSFORM_S_IDX,
                                                2, t); }
    float        SHEAR_XY(float t) { return evalFloat(SOP_UVTRANSFORM_SHEAR_IDX,
                                                0, t); }
    float        SHEAR_XZ(float t) { return evalFloat(SOP_UVTRANSFORM_SHEAR_IDX,
                                                1, t); }
    float        SHEAR_YZ(float t) { return evalFloat(SOP_UVTRANSFORM_SHEAR_IDX,
                                                2, t); }
    float        PX(float t)    { return evalFloat(SOP_UVTRANSFORM_P_IDX,
                                                0, t); }
    float        PY(float t)    { return evalFloat(SOP_UVTRANSFORM_P_IDX,
                                                1, t); }
    float        PZ(float t)    { return evalFloat(SOP_UVTRANSFORM_P_IDX,
                                                2, t); }
    
    // Soft
    float        RADIUS(float t){ return evalFloat(
                                        SOP_UVTRANSFORM_RADIUS_IDX, 0, t); }
    int          SOFTTYPE()     { return evalInt(
                                        SOP_UVTRANSFORM_SOFTTYPE_IDX, 0, 0); }
    float        TANDEG0(float t){ return evalFloat(
                                        SOP_UVTRANSFORM_TANGENT_IDX,0, t); }
    float        TANDEG1(float t){ return evalFloat(
                                        SOP_UVTRANSFORM_TANGENT_IDX,1, t); }
    void         KERNEL(UT_String &str, float t) { evalString(str,
                                        SOP_UVTRANSFORM_KERNEL_IDX, 0, t); }
    int          METRIC()       { return evalInt(
                                        SOP_UVTRANSFORM_METRIC_IDX, 0, 0); }
    int          GLOBAL()       { return evalInt(
                                        SOP_UVTRANSFORM_GLOBAL_IDX, 0, 0); }
    int          UVGLOBAL()     { return evalInt(
                                        SOP_UVTRANSFORM_UVGLOBAL_IDX,0,0); }

    // Group Calculations
    void         computeTransformGroups(bool changed_input);
    void         computeSelectionCentroid();

    // UV Transform
    void         doTransform(float t);

    // Attribute-detecting method
    bool         isVtxUV();

    bool                 myCentroidComputed;
    UT_Vector3           myInitialCentroid;
    
    GB_VertexGroup      *myVtxGroup;
    GB_PointGroup       *myPtGroup;
    
    GEO_SoftTransformPointCache         mySoftPointCache;
    GEO_SoftTransformVertexCache        mySoftVertexCache;
    bool                                mySoftCacheDirty;
};

#endif

---