GU/GU_Skin.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:
 *
 *      Cristin Barghiel
 *      Side Effects Software Inc.
 *      20 Maud St.
 *      Toronto, Ontario,  M5V 2M5
 *      Canada
 *      416-366-4607
 *
 * NAME:        GU_Skin.C (C++)
 *
 * COMMENTS:
 *      This is the filter used to create skinned patches.
 */

#ifndef __GU_Skin_h__
#define __GU_Skin_h__

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

class GB_PrimitiveGroup;
class GU_Detail;

enum GU_SkinClosureType {
    GU_SKIN_CLOSE_NONE  = 0,
    GU_SKIN_CLOSE       = 1,
    GU_SKIN_CLOSE_AUTO  = 2
};

typedef UT_PtrArray<GEO_Primitive*> TGEOPrimsArray;

/// This class can be used to queue up all primitives that are
/// to be deleted, with actual deletion being done once the operation
/// is complete. 
/// 
/// This is particularly useful when an operation is performed on 
/// multiple groups within one detail, since each deletion opeartion
/// itself is O(n) where n is the number of primitives in the detail.
/// Thus, accumulating primitives that are to be deleted and deleting them
/// once instead of every time for every group can lead to signficantly
/// faster code.
class GU_API GU_SkinCache
{
public:
    GU_SkinCache(GEO_Detail& parent_detail);
    virtual ~GU_SkinCache();

    /// Queues up an array of primitives to delete. If delete_points is true,
    /// will delete primitives' points as well. All queued primitives are
    /// deleted either by calling cleanup() or in the destructor.
    void addCleanupPrimitives(TGEOPrimsArray* prims_array, bool delete_points);

    /// Queues up a single primitive to delete. If delete_points is true,
    /// will delete primitives' points as well. All queued primitives are
    /// deleted either by calling cleanup() or in the destructor.
    void addCleanupPrimitive(GEO_Primitive* prim, bool delete_points);

    /// Deletes all queued up primitives.
    virtual void cleanup(void);

private:
    /// Disable the assignment operator. We don't need to copy the arrays
    /// entirely (slow) and at the same time we don't want pointers being
    /// shared between multiple objects.
    GU_SkinCache& operator=(const GU_SkinCache &source) { return *this; }

private:

    /// Holds pointers to primitives whose points also have to be deleted
    TGEOPrimsArray *myCleanupPrimsDeletePoints;

    /// Holds pointers to primitives whose points are to be left alone
    TGEOPrimsArray *myCleanupPrimsLeavePoints;

    /// Parent detail of the above primitives. For now we only support deleting
    /// primitives from one detail, but this can easily be extended to support
    /// multiple ones without changing external functions.
    GEO_Detail* myParentDetail;
};

class GU_API GU_SkinParms
{
public:
    GU_SkinParms(); 
    virtual ~GU_SkinParms();

    void ConvertGroupToPrimsArray(GEO_Detail* parent_detail, const GB_PrimitiveGroup& group, TGEOPrimsArray& prims_array);
    virtual void InitializePrimArrays(GEO_Detail* parent_detail);

    GEO_SurfaceType              surfType;
    int                          vOrder;
    GU_SkinClosureType           vWrap;
    int                          keepShape;     // ruled or truly skinned
    const GB_PrimitiveGroup     *uFaces;

    TGEOPrimsArray *myUPrimsToProcess;
};

#endif

---