GEO_VolumeElement.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_VolumeElement.h (GEO Library, C++)
 *
 * COMMENTS:    This is a wrapper to handle volume elements
 *              In particular it allows using these primitives without
 *              creating the underlying primitive type.
 */

#pragma once

#ifndef __GEO_VolumeElement__
#define __GEO_VolumeElement__

#include "GEO_API.h"
#include "GEO_PrimTetrahedron.h"
#include "GEO_PrimHexahedron.h"
#include <GA/GA_Defines.h>
#include <GA/GA_PrimitiveTypes.h>
#include <SYS/SYS_Inline.h>
#include <UT/UT_Array.h>

#define DISPATCH(TYPEID, FUNCTION, ...) \
switch ((TYPEID).get()) \
{ \
    case GA_PRIMTETRAHEDRON: \
        return GEO_PrimTetrahedron::FUNCTION(__VA_ARGS__); \
    case GA_PRIMHEXAHEDRON: \
        return GEO_PrimHexahedron::FUNCTION(__VA_ARGS__); \
} \
/**/


class GEO_API GEO_VolumeElement
{
public:
    SYS_FORCE_INLINE
    GEO_VolumeElement()
    {
        myDetail = nullptr;
        myOffset = GA_INVALID_OFFSET;
        myType = GA_PRIMNONE;
    }

    SYS_FORCE_INLINE
    GEO_VolumeElement(const GA_Detail *gdp, GA_Offset offset = GA_INVALID_OFFSET)
    {
        bind(gdp, offset);
    }

    /// This lets you create a stack-version of the primitive so you can
    /// duck-type directly to GEO_PrimTetrahedron, GEO_PrimHexahedron, etc.
    /// Usage:
    /// GEO_VolumeElement::dispatch(type, gdp, primoff,
    ///     [&](auto &prim)
    /// {
    ///     prim.normal(comp);
    /// });
    /// will be the equivalent of creating a stack GEO_PrimTetrahedon(gdp,
    /// primoff) and calling normal on it.
    /// 
    /// To retreive the actual type you can use decltype
    ///
    /// GEO_VolumeElement::dispatch(type, gdp, primoff,
    ///     [&](auto &prim)
    /// {
    ///     using PrimT = SYS_RemoveCVRef_t<decltype(prim)>;
    ///     typename PrimT::Face face(prim, i);
    /// });
    template <typename OP>
    static void dispatch(GA_PrimitiveTypeId type, const GA_Detail *gdp, GA_Offset offset, OP op)
    {
        UT_ASSERT(gdp);
        UT_ASSERT(GAisValid(offset));
        switch (type.get())
        {
            case GA_PRIMTETRAHEDRON:
            {
                const GEO_PrimTetrahedron prim(SYSconst_cast(gdp), offset, gdp->getPrimitiveVertexList(offset));
                op(prim);
                break;
            }
            case GA_PRIMHEXAHEDRON:
            {
                const GEO_PrimHexahedron prim(SYSconst_cast(gdp), offset, gdp->getPrimitiveVertexList(offset));
                op(prim);
                break;
            }
            default:
            {
                UT_ASSERT(!"Unhandled volume type.");
                break;
            }
        }
    }

    template <typename OP>
    static void dispatch(const GA_Detail *gdp, GA_Offset offset, OP op)
    {
        UT_ASSERT(gdp);
        UT_ASSERT(GAisValid(offset));
        dispatch(gdp->getPrimitiveTypeId(offset), gdp, offset, op);
    }

    template <typename OP>
    static void dispatch(GA_PrimitiveTypeId type, const GA_Primitive *baseprim, OP op)
    {
        UT_ASSERT(baseprim);
        switch (type.get())
        {
            case GA_PRIMTETRAHEDRON:
            {
                const GEO_PrimTetrahedron *prim = (const GEO_PrimTetrahedron *) baseprim;
                op(*prim);
                break;
            }
            case GA_PRIMHEXAHEDRON:
            {
                const GEO_PrimHexahedron *prim = (const GEO_PrimHexahedron *) baseprim;
                op(*prim);
                break;
            }
            default:
            {
                UT_ASSERT(!"Unhandled volume type.");
                break;
            }
        }
    }

    bool        isValid() const
    {
        if (!myDetail) return false;
        if (!GAisValid(myOffset)) return false;
        if (GAisVolumeElement(myType)) return true;
        return false;
    }

    void        bind(const GA_Detail *gdp, GA_Offset offset)
    {
        myDetail = gdp;
        myOffset = offset;
        myType = GA_PRIMNONE;
        if (myDetail && GAisValid(myOffset))
        {
            myType = myDetail->getPrimitiveTypeId(myOffset);
        }
    }

    /// Update the element to point to another primitive in same detail
    void        setOffset(GA_Offset offset)
    {
        UT_ASSERT(myDetail);
        myOffset = offset;
        if (myDetail && GAisValid(myOffset))
        {
            myType = myDetail->getPrimitiveTypeId(myOffset);
        }
    }

    const GA_Detail   *detail() const { return myDetail; }
    GA_Offset    getMapOffset() const { return myOffset; }
    GA_PrimitiveTypeId typeId() const { return myType; }

    static GA_Size getVertexCount(GA_PrimitiveTypeId type, const GA_Detail *gdp, GA_Offset offset)
    { DISPATCH(type, rawVertexCount); return 0; }
    GA_Size        getVertexCount() const
    { return getVertexCount(myType, myDetail, myOffset); }

    /// Return shallow copy of the vertex list
    static GA_OffsetListRef getVertexList(const GA_Detail *gdp, GA_Offset offset)
    { return gdp->getPrimitiveVertexList(offset); }
    GA_OffsetListRef getVertexList() const
    { return getVertexList(myDetail, myOffset); }

    /// Return the vertex offset from a given vertex index.
    static GA_Offset getVertexOffset(const GA_Detail *gdp, GA_Offset offset, GA_Size index)
    { return gdp->getPrimitiveVertexOffset(offset, index); }
    GA_Offset getVertexOffset(GA_Size index) const
    { return getVertexOffset(myDetail, myOffset, index); }

    /// Return the point offset from a given vertex index.
    static GA_Offset getPointOffset(const GA_Detail *gdp, GA_Offset offset, GA_Size index)
    { return gdp->vertexPoint(getVertexOffset(gdp, offset, index)); }
    GA_Offset getPointOffset(GA_Size index) const
    { return getPointOffset(myDetail, myOffset, index); }

    /// The number of faces that make up this volume
    static GA_Size getFaceCount(GA_PrimitiveTypeId type, const GA_Detail *d, GA_Offset offset)
    { DISPATCH(type, rawFaceCount); return 0; }
    GA_Size     getFaceCount() const
    { return getFaceCount(myType, myDetail, myOffset); }

    /// Returns the indices to the vertices, not the vertex offsets!
    static int  getFaceIndices(GA_PrimitiveTypeId type, const GA_Detail *gdp, GA_Offset offset, GA_Size faceno, UT_Array<int> &vtxlist)
    { DISPATCH(type, rawFaceIndices, gdp, offset, faceno, vtxlist); return 0;  }
    int         getFaceIndices(GA_Size faceno, UT_Array<int> &vtxlist) const
    { return getFaceIndices(myType, myDetail, myOffset, faceno, vtxlist); }

    /// Returns the number of indices in specified face
    static int  getFaceIndexCount(GA_PrimitiveTypeId type, const GA_Detail *gdp, GA_Offset offset, GA_Size faceno)
    { DISPATCH(type, rawFaceIndexCount, gdp, offset, faceno); return 0;  }
    int         getFaceIndexCount(GA_Size faceno) const
    { return getFaceIndexCount(myType, myDetail, myOffset, faceno); }

    static GA_Offset findSharedFace(GA_PrimitiveTypeId type, const GA_Detail *gdp, GA_Offset offset, GA_Size faceno);
    GA_Offset findSharedFace(GA_Size faceno) const
    { return findSharedFace(myType, myDetail, myOffset, faceno); }

    /// The number of edges in this volume.
    static GA_Size getEdgeCount(GA_PrimitiveTypeId type, const GA_Detail *gdp, GA_Offset offset)
    { DISPATCH(type, rawEdgeCount); return 0; }
    GA_Size     getEdgeCount() const
    { return getEdgeCount(myType, myDetail, myOffset); }

    /// Returns the indices of the edge.  Note each edge shows up once
    /// and due to the nature of volumes, is undirected.
    static void getEdgeIndices(GA_PrimitiveTypeId type, const GA_Detail *gdp, GA_Offset offset, GA_Size edgeno, int &e0, int &e1)
    { DISPATCH(type, rawEdgeIndices, gdp, offset, edgeno, e0, e1); }
    void        getEdgeIndices(GA_Size edgeno, int &e0, int &e1) const
    { getEdgeIndices(myType, myDetail, myOffset, edgeno, e0, e1); }

    /// Evaluate the interior point weights
    static void computeInteriorPointWeights(GA_PrimitiveTypeId type, const GA_Detail *gdp, GA_Offset offset, UT_Array<GA_Offset> &vtxlist, UT_Array<float> &weightlist, fpreal u, fpreal v, fpreal w)
    { DISPATCH(type, rawComputeInteriorPointWeights, gdp, offset, vtxlist, weightlist, u, v, w) }
    void computeInteriorPointWeights(UT_Array<GA_Offset> &vtxlist, UT_Array<float> &weightlist, fpreal u, fpreal v, fpreal w)
    { computeInteriorPointWeights(myType, myDetail, myOffset, vtxlist, weightlist, u, v, w); }

protected:
    const GA_Detail     *myDetail;
    GA_Offset            myOffset;
    GA_PrimitiveTypeId   myType;
};

#endif