GEO_Mirror.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.
 *
 * NAME:        GEO Library.
 *
 * COMMENTS:    Geometry mirroring
 *
 */
#ifndef __GEO_Mirror_h__
#define __GEO_Mirror_h__

#include "GEO_API.h"

#include <GA/GA_IndexMap.h>
#include <UT/UT_Array.h>
#include <UT/UT_Vector3.h>

class GA_PrimitiveGroup;
class GEO_Detail;

// Provides mapping between mirrored elements and the original source element
class GEO_MirrorRedirectMap
{
public:
    // Provides mapping between mirrored elements for a particular class:
    // primitives, points, or vertices
    class ElementRedirect
    {
    public:
        ElementRedirect() : myStart(0), myEnd(0) {}

        // Map GA_Offset of a mirrored element in the destination geometry to
        // the corresponding item in the source geometry.
        GA_Offset getSourceElement(const GA_IndexMap &src_map,
                                   const GA_IndexMap &dst_map,
                                   GA_Offset dst_offset) const
        {
            GA_Index src_idx = dst_map.indexFromOffset(dst_offset) - myStart;
            if (myLookup.entries())
                src_idx = myLookup(src_idx);
            return src_map.offsetFromIndex(src_idx);
        }

        // Map GA_Offset of a mirrored element in the destination geometry to
        // the corresponding original item in the destination geometry.
        // This should only be called if 'keep_original' was specified when
        // mirroring.
        GA_Offset getSourceElement(const GA_IndexMap &dst_map,
                                   const GA_Index base,
                                   GA_Offset dst_offset) const
        {
            GA_Index src_idx = dst_map.indexFromOffset(dst_offset) - myStart;
            if (myLookup.entries())
                src_idx = myLookup(src_idx);
            return dst_map.offsetFromIndex(base + src_idx);
        }

        // GA_Index of the first mirrored component
        GA_Index myStart;
        // GA_Index of the last mirrored component + 1
        GA_Index myEnd;

        // Explicit lookup table used to identify source components if only a
        // subset of the source geometry was mirrored.
        UT_Array<GA_Index> myLookup;
    };

    GEO_MirrorRedirectMap() : myPtBase(-1) {}

    // When isValid() is true, the redirect map can be used to map from
    // destination elements back to the corresponding source elements
    bool isValid() const { return myPtBase >= 0; }
    void setInvalid() { myPtBase = -1; }

    // Number of points in the destination geometry before mirroring
    GA_Index myPtBase;
    // Number of vertices in the destination geometry before mirroring
    GA_Index myVtxBase;

    ElementRedirect myPrimitiveRedirect;
    ElementRedirect myPointRedirect;
    ElementRedirect myVertexRedirect;
};

// Parameters for the mirror method
class GEO_API GEO_MirrorParms
{
public:
    // Reverse option for primitives that have been mirrored
    enum GEO_ReverseOption
    {
        GEO_MIRROR_NO_REVERSE = 0,
        GEO_MIRROR_REVERSE    = 1,
        GEO_MIRROR_REVERSE_U  = 2,
        GEO_MIRROR_REVERSE_V  = 3
    };

    // Constructor
    GEO_MirrorParms(const GEO_Detail            *src_gdp,
                    const GA_PrimitiveGroup     *prims_to_mirror,
                    const UT_Vector3R           &mirror_normal,
                    const UT_Vector3R           &mirror_origin,
                    fpreal                       dist,
                    bool                         keep_original,
                    GEO_ReverseOption            reverse_direction,
                    bool                         consolidate_seam,
                    fpreal                       consolidate_tolerance,
                    bool                         consolidate_unshared,
                    GEO_MirrorRedirectMap       *redirect_map)
        : mySourceGdp(src_gdp)
        , myPrimsToMirror(prims_to_mirror)
        , myMirrorNormal(mirror_normal)
        , myMirrorOrigin(mirror_origin)
        , myDist(dist)
        , myKeepOriginal(keep_original)
        , myReverseDirection(reverse_direction)
        , myConsolidateSeam(consolidate_seam)
        , myConsolidateTolerance(consolidate_tolerance)
        , myConsolidateUnshared(consolidate_unshared)
        , myRedirectMap(redirect_map)
      {
      }

    const GEO_Detail            *mySourceGdp; // Source gdp
    const GA_PrimitiveGroup     *myPrimsToMirror; // Group belonging to srcgdp

    UT_Vector3R                  myMirrorNormal; // must be normalized
    UT_Vector3R                  myMirrorOrigin;
    fpreal                       myDist;
    bool                         myKeepOriginal;
    GEO_ReverseOption            myReverseDirection;
    bool                         myConsolidateSeam;
    fpreal                       myConsolidateTolerance;
    bool                         myConsolidateUnshared;

    // When myRedirectMap not null and valid, tells mirror that the geometry
    // is all in place, all we have to do is move points.  The redirect map
    // will be used to figure out how to map from mirrored element to the
    // original element.  If myRedirect is non-null and invalid then it is
    // filled with the information you can use next time around.
    GEO_MirrorRedirectMap               *myRedirectMap;
};
#endif