GU/GU_Copy.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
 *      477 Richmond Street West
 *      Toronto, Ontario
 *      Canada   M5V 3E7
 *      416-504-9876
 *
 * NAME:        GU_Copy.h ( GU Library, C++)
 *
 * COMMENTS:    Copy one gdp with a transform.  Optionally with a template
 *              object
 *
 *              When a template is used, the copies will be made in the
 *              loop order:
 *                      foreach template_point {
 *                          foreach copy {
 *                              getmatrix();
 *                              makecopy();
 *                          }
 *                      }
 *              This allows for a cumulative transform to be applied.
 */

#ifndef __GU_Copy__
#define __GU_Copy__

#include "GU_API.h"
#include <UT/UT_VectorTypes.h>
class GB_PrimitiveGroup;
class GB_PointGroup;
class GU_Detail;
class UT_String;
class UT_Interrupt;

class gu_CopyAttribMap;

typedef int     (*GU_CopyTransformCallback)(UT_Matrix4 &, int copynum,
                                const GEO_Point *template_point,
                                int template_pt_num, void *data);

typedef int     (*GU_CopyGroupNameCallback)(UT_String &, void *data);

typedef int     (*GU_CopySourceCallback) 
                        (const GU_Detail *&src, const GB_PrimitiveGroup *&grp,
                         void *data);
                                

class GU_API GU_CopyParms {
public:
     GU_CopyParms();
    ~GU_CopyParms();

    enum        GU_AttribOp { GU_SET_ATTRIB,
                              GU_ADD_ATTRIB,
                              GU_SUB_ATTRIB,
                              GU_MUL_ATTRIB };

    void        setTemplate(const GU_Detail &gdp, const GB_PointGroup *ptgrp=0);

    // Patterns for attribute copying from template to copies...
    // The template geometry must be set before these methods are called
    void        setPointAttrib(const char *pattern, GU_AttribOp op);
    void        setPrimAttrib(const char *pattern, GU_AttribOp op);
    void        setVertexAttrib(const char *pattern, GU_AttribOp op);
    void        setKeepVectorLength(int onoff) { myKeepFlag = onoff; }
    void        setPreserveGroups(int onoff) { myPreserveGroups = onoff; }
    void        setTransformCallback(GU_CopyTransformCallback callback)
                {
                    myXformCallback = callback;
                }
    void        setGroupNameCallback(GU_CopyGroupNameCallback callback)
                {
                    myGNameCallback = callback;
                }

    // If a setSource is used, the callback is ignored.

    void        setSource(const GU_Detail *gdp,
                          const GB_PrimitiveGroup *primgrp=0)
                {
                    mySource = gdp;
                    myPrimGroup = primgrp;
                }

    void        setSourceCallback(GU_CopySourceCallback callback)
                {
                    mySourceCallback = callback;
                }

    void        copy(GU_Detail &gdp, int ncopies, void *data = 0);

private:

    void        transform(GU_Detail *gdp, const UT_Matrix4 &xform,
                          GB_PrimitiveGroup *grp, int primcnt,
                          int ptcnt,
                          const GEO_Point *tppt = 0);

    int         singleCopy(GU_Detail *gdp, int ncopies, void *data,
                           const GEO_Point *ptptr, int tnum, int ltnum,
                           UT_Interrupt *boss);

    void        setAttribMap(gu_CopyAttribMap *&, const char *pattern,
                             GU_AttribOp op);   

    // Ensure that we have the correct attributes on gdp and that the offsets
    // are correct (c.f. the src).  We append any maps after the source
    // attribs.
    void        fixAttribMaps(GU_Detail &gdp, const GU_Detail *src);

    // Apply the operations to the point/primitive/vertex attributes
    void        applyPointMap(GEO_Point *ppt, const GEO_Point *tppt);
    void        applyPrimMap(GEO_Primitive *prim, const GEO_Point *tppt);

    GU_CopyTransformCallback     myXformCallback;
    GU_CopyGroupNameCallback     myGNameCallback;
    GU_CopySourceCallback        mySourceCallback;
    const GU_Detail             *myTemplate;
    const GU_Detail             *mySource;
    const GB_PrimitiveGroup     *myPrimGroup;
    const GB_PointGroup         *myPointGroup;
    gu_CopyAttribMap            *myPointMap;
    gu_CopyAttribMap            *myPrimMap;
    gu_CopyAttribMap            *myVertexMap;

    int                          mySourcePointCount;
    int                          mySourcePrimCount;
    int                          myXformFlag;
    int                          myKeepFlag;
    int                          myPreserveGroups;
};

#endif

---