GU/GU_ConvertParms.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:
 *      Dale Ducharme
 *      Side Effects Software Inc.
 *      20 Maud St.
 *      Toronto, Ontario,  M5V 2M5
 *      Canada
 *      416-366-4607
 *
 * NAME:        GU_Prim.h (C++)
 *
 * COMMENTS:    The GU_Prim class is a the base class for which all
 *              the primitive classes are subclassed off of.  Common 
 *              utility operations are done here like conversion from one
 *              primitive to another.
 * 
 */

#ifndef __GU_ConvertParms_h__
#define __GU_ConvertParms_h__

#include "GU_API.h"
#include <GEO/GEO_Detail.h>
#include <GEO/GEO_SurfaceType.h>

class UT_Vector3;
class GB_PrimitiveGroup;
class GB_PointGroup;
class GU_Detail;

enum GU_ConvertStyle
{
    GU_CONVERT_LOD      = 0,    // use float level of detail
    GU_CONVERT_DIV      = 1     // use integer divisions
};

typedef union
{
    float       lod;
    int         div;
} GU_ConvertUnion;

class GU_API GU_ConvertMethod
{
public:
    GU_ConvertMethod(GU_ConvertStyle s = GU_CONVERT_LOD) : style(s) {}

    int         isLOD() const   { return style == GU_CONVERT_LOD;  }
    int         isDiv() const   { return style == GU_CONVERT_DIV;  }

    void        doLOD()         { style = GU_CONVERT_LOD;  }
    void        doDiv()         { style = GU_CONVERT_DIV;  }

    float       getULOD() const    { return isLOD() ? u.lod    : u.div;    }
    float       getVLOD() const    { return isLOD() ? v.lod    : v.div;    }
    float       getTrimLOD() const { return isLOD() ? trim.lod : trim.div; }

    void        setULOD(float lod)      { doLOD(); u.lod = lod;    }
    void        setVLOD(float lod)      { doLOD(); v.lod = lod;    }
    void        setTrimLOD(float lod)   { doLOD(); trim.lod = lod; }

    int         validULOD() const
                { return !isLOD() || (isLOD() && (u.lod > 0));    }
    int         validVLOD() const
                { return !isLOD() || (isLOD() && (v.lod > 0));    }
    int         validTrimLOD() const
                { return !isLOD() || (isLOD() && (trim.lod > 0)); }

    int         getUDiv() const         { return u.div;    }
    int         getVDiv() const         { return v.div;    }
    int         getTrimDiv() const      { return trim.div; }

    void        setUDiv(int div)        { doDiv(); u.div = div;    }
    void        setVDiv(int div)        { doDiv(); v.div = div;    }
    void        setTrimDiv(int div)     { doDiv(); trim.div = div; }

    int         validUDiv() const       { return isDiv() && (u.div >= 0);    }
    int         validVDiv() const       { return isDiv() && (v.div >= 0);    }
    int         validTrimDiv() const    { return isDiv() && (trim.div >= 0); }

private:
    GU_ConvertUnion     u;
    GU_ConvertUnion     v;
    GU_ConvertUnion     trim;
    GU_ConvertStyle     style;
};


class GU_API GU_ConvertParms
{
public:

     GU_ConvertParms();
    ~GU_ConvertParms();

    unsigned             fromType;
    unsigned             toType;

    int                  orderu;
    int                  orderv;
    GEO_SurfaceType      surface;

    GU_ConvertMethod     method;
    int                  interpHull;
    int                  trimmed;       // trimmed spline surface

    int                  featureCoord;  // 1 feature, 0 base (for pasting)
    int                  featureAttrib; // 1 feature, 0 base (for pasting)
    int                  myMetaClusterFlag;

    float                myOffset;      // Used for biasing isosurfaces.

    int                  preserveGroups;

    // Warning: This primGroup is potentially modified by the conversion
    GB_PrimitiveGroup   *primGroup;

    // If the gdp passed in is null, then no group will be created, the
    // existing group (if any) will be returned.
    // The user of the convert parms is required to blow these groups away
    GB_PointGroup       *getDeletePoints(GU_Detail *gdp = 0);
    GB_PrimitiveGroup   *getDeletePrimitives(GU_Detail *gdp = 0);
    void                 clearGroups()
                         {
                             myDeletePoints = 0;
                             myDeletePrimitives = 0;
                         }

private:
    GB_PointGroup       *myDeletePoints;        // Extra points to delete
    GB_PrimitiveGroup   *myDeletePrimitives;    // Extra primitives to delete
};

#endif

---