GEO_VolumeElementBase.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_VolumeElementBase.h (GEO Library, C++)
 *
 * COMMENTS:    This is the base class for all volume element types.
 */

#pragma once

#ifndef __GEO_VolumeElementBase__
#define __GEO_VolumeElementBase__

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

class GA_Detail;

class GEO_API GEO_VolumeElementBase : public GEO_Primitive
{
public:
    SYS_FORCE_INLINE
    GEO_VolumeElementBase(GA_Detail *d, GA_Offset offset = GA_INVALID_OFFSET)
        : GEO_Primitive(d, offset)
    {}

    /// The number of faces that make up this volume
    virtual GA_Size     getFaceCount() const = 0;
    /// Returns the indices to the vertices, not the vertex offsets!
    virtual int         getFaceIndices(GA_Size faceno, UT_Array<int> &vtxlist) const = 0;
    /// Returns the number of indices in specified face.
    virtual int         getFaceIndexCount(GA_Size faceno) const = 0;

    /// Returns any primitive sharing the face of the same type,
    /// so tet only returns tet and hex only returns hex.
    /// See volumelement for a more general version.
    virtual GA_Offset findSharedFace(GA_Size faceno) const = 0;

    /// The number of edges in this volume.
    virtual GA_Size     getEdgeCount() const = 0;
    /// Returns the indices of the edge.  Note each edge shows up once
    /// and due to the nature of volumes, is undirected.
    virtual void        getEdgeIndices(GA_Size edgeno, int &e0, int &e1) const = 0;
    bool hasEdge(const GA_Edge &edge) const override
    {
        for (GA_Size i = 0, nedge = getEdgeCount(); i < nedge; ++i)
        {
            int i0, i1;
            getEdgeIndices(i, i0, i1);
            GA_Offset p0 = getPointOffset(i0);
            GA_Offset p1 = getPointOffset(i1);
            if ((edge.p0() == p0 && edge.p1() == p1) ||
                (edge.p0() == p1 && edge.p1() == p0))
                return true;
        }
        return false;
    }
    
    void iterateEdges(GA_IterateEdgesFunc apply_func) const override
    {
        for (int i = 0, nedge = getEdgeCount(); i < nedge; ++i)
        {
            int i0; int i1;
            getEdgeIndices(i, i0, i1);
            // Both directions are present
            if (!apply_func(GA_Edge(getPointOffset(i0), getPointOffset(i1))))
                return;
            if (!apply_func(GA_Edge(getPointOffset(i1), getPointOffset(i0))))
                return;
        }
    }
    
    void iterateEdgesByVertex(GA_IterateEdgesByVertexFunc apply_func) const override
    {
        for (int i = 0, nedge = getEdgeCount(); i < nedge; ++i)
        {
            int i0; int i1;
            getEdgeIndices(i, i0, i1);
            
            // Both directions are present
            if (!apply_func(i0, i1) || !apply_func(i1, i0))
                return;
        }
    }

    bool                getBBox(UT_BoundingBox *bbox) const override;
    void                addToBSphere(UT_BoundingSphere *bsphere) const override;
    UT_Vector3          baryCenter() const override;
    UT_Vector3D         baryCenterD() const override;
    UT_Vector3          computeNormal() const override;
    UT_Vector3D         computeNormalD() const override;

#if !GA_PRIMITIVE_VERTEXLIST
    virtual void        addPointRefToGroup(GA_PointGroup &grp) const;

    virtual bool         vertexApply(bool (*apply)(GA_Offset vtx, void *),
                                     void  *data = 0) const;
#endif

    /// Builds volumeelements using the specified range of point offsets,
    /// as dictated by nprims and primpointnumbers, in parallel.
    /// primpointnumbers lists the *offsets* of the points used by
    /// each volumeelemnt *MINUS* startpt, i.e. they are offsets relative to
    /// startpt, *not* indices relative to startpt. The offset of the first
    /// hexahedron is returned, and the rest are at consecutive offsets. All
    /// hexpointnumbers must be between 0 (inclusive) and npoints (exclusive).
    ///
    /// NOTE: Existing primitives *are* allowed to be using the points in
    /// the specified range already, and the elements being created do not
    /// do not need to use all of the points in the range.  However,
    /// these cases may impact performance.
    static GA_Offset buildBlock(GA_Detail *detail,
        const GA_Offset startpt,
        const GA_Size npoints,
        const GA_Size nprims,
        GA_PrimitiveTypeId primtype,
        int vertexperprim,
        const int *primpointnumbers);

protected:
    static GA_PrimitiveFamilyMask       buildFamilyMask()
                                            { return GA_FAMILY_VOLUMEELEMENT; }

    /// All subclasses should call this method to register the intrinsics.
    /// @see GA_IntrinsicManager
    static GA_IntrinsicManager::Registrar
                        registerIntrinsics(GA_PrimitiveDefinition &defn)
                            { return GEO_Primitive::registerIntrinsics(defn); }
    
    bool                 evaluatePointRefMap(
                                GA_Offset result_vtx,
                                GA_AttributeRefMap &hlist,
                                fpreal u, fpreal v,
                                uint du, uint dv) const override;
    int                  evaluatePointV4(
                                UT_Vector4 &pos,
                                float u, float v = 0,
                                unsigned du=0, unsigned dv=0) const override
                         {
                            return GEO_Primitive::evaluatePointV4(pos, u, v,
                                        du, dv);
                         }
    bool                 evaluateBaryCenterRefMap(
                                GA_Offset result_vertex,
                                GA_AttributeRefMap &hlist) const override;

SYS_DEPRECATED_PUSH_DISABLE()
};
SYS_DEPRECATED_POP_DISABLE()

#endif