GT_GEOElementArray.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:        GT_GEOElementArray.h ( GEO Library, C++)
 *
 * COMMENTS:
 */

#ifndef __GT_GEOElementArray__
#define __GT_GEOElementArray__

#include "GT_API.h"
#include <UT/UT_Assert.h>
#include "GT_DataArray.h"
#include "GT_GEOSupport.h"
#include <GA/GA_AIFTuple.h>
#include <GA/GA_AIFStringTuple.h>
#include <GU/GU_Detail.h>
#include <GA/GA_Handle.h>

class GA_AIFSharedStringTuple;
class GA_Attribute;

/// @brief A GT Data Array to extract values from a point/primitive attribute.
class GT_API GT_GEOElementArray : public GT_DataArray
{
public:
    enum GT_GEOAttributeOwner
    {
        GT_GEOATTRIB_INVALID = -1,

        GT_GEOATTRIB_VERTEX = GA_ATTRIB_VERTEX,
        GT_GEOATTRIB_POINT = GA_ATTRIB_POINT,
        GT_GEOATTRIB_PRIMITIVE = GA_ATTRIB_PRIMITIVE,
        GT_GEOATTRIB_GLOBAL = GA_ATTRIB_GLOBAL,
        GT_GEOATTRIB_DETAIL = GA_ATTRIB_DETAIL,

        // Point attribute indexed by vertex
        GT_GEOATTRIB_VERTEX_POINT,
        // Primitive attribute index by vertex
        GT_GEOATTRIB_VERTEX_PRIMITIVE,
        // Detail attribute indexed by vertex
        GT_GEOATTRIB_VERTEX_DETAIL,

        // Detail attribute indexed by primitive
        GT_GEOATTRIB_PRIMITIVE_DETAIL,
    };
    /// The @c index_mode is used to lookup values.  This does @b not
    /// necessarily have to match the attribute owner, but it must be one of
    /// the following.
    /// - @c index_mode := point, @c attribute := point @n
    /// - @c index_mode := vertex, @c attribute := point @n
    /// - @c index_mode := vertex, @c attribute := primitive @n
    /// - @c index_mode := vertex, @c attribute := vertex @n
    /// - @c index_mode := primitive, @c attribute := primitive @n
    /// - @c index_mode := detail, @c attribute := detail @n
    GT_GEOElementArray(const GU_ConstDetailHandle &gdp,
                        const GA_Attribute *attrib,
                        const GT_GEOOffsetList &offsets,
                        GA_AttributeOwner offset_owner);
    GT_GEOElementArray(const GT_GEOElementArray &src_array,
                       const GT_GEOOffsetList &offsets,
                       GA_AttributeOwner offset_owner);
    ~GT_GEOElementArray() override;

    const char          *className() const override
                            { return "GT_GEOElementArray"; }

    /// @{
    /// Query methods defined on GT_DataArray
    GT_Storage          getStorage() const override
                            { return myStorage; }
    GT_Size             entries() const override
                        {
                            return myOffsets.entries();
#if 0
                            switch (myOffsetOwner)
                            {
                                case GA_ATTRIB_VERTEX:
                                    return myGdp->getNumVertexOffsets();
                                case GA_ATTRIB_POINT:
                                    return myGdp->getNumPointOffsets();
                                case GA_ATTRIB_PRIMITIVE:
                                    return myGdp->getNumPrimitiveOffsets();
                                case GA_ATTRIB_DETAIL:
                                    return 1;
                                default:
                                    UT_ASSERT(0);
                            }
#endif
                            return 0;
                        }
    GT_Size             itemSize(GT_Offset offset) const override;
    GT_Size             getTotalArrayEntries() const override;
    GT_Size             getTupleSize() const override
                        {
                            return myTupleSize;
                        }
    GT_Type             getTypeInfo() const override
                        {
                            GA_TypeInfo info = myAttribute
                                ? myAttribute->getTypeInfo()
                                : GA_TYPE_VOID;
                            // avoid transforming attributes like "rest"
                            switch(info)
                            {
                                case GA_TYPE_POINT:
                                case GA_TYPE_HPOINT:
                                case GA_TYPE_NORMAL:
                                case GA_TYPE_VECTOR:
                                    if(!myAttribute->needsTransform())
                                        return GT_TYPE_NONE;
                                    break;

                                default:
                                    break;
                            }
                            return mapTypeInfo(info, myTupleSize);
                        }
    int64               getMemoryUsage() const override
                            { return sizeof(*this); }
    bool                isValid() const override { return myAttribute != NULL; }
    bool                hasArrayEntries() const override
                        {
                            return myFA.isValid() ||
                                   myIA.isValid() ||
                                   myIA64.isValid() || 
                                   mySSArray ||
                                   mySDictArray;
                        }
    void                updateGeoDetail(const GU_ConstDetailHandle &dtl,
                                        const char *name,
                                        GT_Owner attrib_scope,
                                        const int expected_size) override;

    /// @}

    /// @{
    /// Access methods defined on GT_DataArray
    fpreal16            getF16(GT_Offset offset, int idx) const override
                            { return getValue_t<fpreal32>(offset, idx); }
    fpreal32            getF32(GT_Offset offset, int idx) const override
                            { return getValue_t<fpreal32>(offset, idx); }
    fpreal64            getF64(GT_Offset offset, int idx) const override
                            { return getValue_t<fpreal64>(offset, idx); }
    uint8               getU8(GT_Offset offset, int idx) const override
                            { return getValue_t<int32>(offset, idx); }
    int32               getI32(GT_Offset offset, int idx) const override
                            { return getValue_t<int32>(offset, idx); }
    int64               getI64(GT_Offset offset, int idx) const override
                            { return getValue_t<int64>(offset, idx); }
    GT_String           getS(GT_Offset offset, int idx) const override
                        {
                            if (mySTuple)
                            {
                                GA_Offset        si = getDataOffset(offset);
                                return mySTuple->getString(myAttribute, si,idx);
                            }
                            return UT_StringHolder::theEmptyString;
                        }
    bool                getSA(UT_StringArray &a,
                              GT_Offset offset) const override
                        {
                            if (mySSArray)
                            {
                                GA_Offset       si = getDataOffset(offset);
                                mySSArray->getString(myAttribute, si, a);
                                return true;
                            }
                            return false;
                        }
    GT_Dict             getDict(GT_Offset offset, int idx = 0) const override
                        {
                            if (mySDictTuple)
                            {
                                GA_Offset si = getDataOffset(offset);
                                return mySDictTuple->getDict(myAttribute, si, idx);
                            }
                            return UT_OptionsHolder::theEmptyOptions;
                        }
    bool                getDictA(UT_Array<UT_OptionsHolder> &a, GT_Offset offset) const override
                        {
                            if (mySDictArray)
                            {
                                GA_Offset si = getDataOffset(offset);
                                mySDictArray->getDict(myAttribute, si, a);
                                return true;
                            }
                            return false;
                        }
    GT_Size             getStringIndexCount() const override;
    GT_Offset           getStringIndex(GT_Offset offset,
                                       int idx=0) const override;
    void                getIndexedStrings(UT_StringArray &,
                                          UT_IntArray &) const override;

    void                fillStringArray(UT_StringArray &data, UT_ValArray<int> &sizes,
                                        GT_Offset start, GT_Size length) const override;

    GT_Size                 getDictIndexCount() const override;
    GT_Offset           getDictIndex(GT_Offset offset, int idx = 0) const override;
    void                getIndexedDicts(UT_Array<UT_OptionsHolder> &,
                                          UT_IntArray &) const override;

    void                    fillDictionaryArray(UT_Array<UT_OptionsHolder> &data, UT_ValArray<int> &sizes,
                                          GT_Offset start, GT_Size length) const override;

    bool                getFA16(UT_ValArray<fpreal16> &a,
                                GT_Offset offset) const override
                            { return getArrayValue_t<fpreal16>(a,offset); }
    bool                getFA32(UT_ValArray<fpreal32> &a,
                                GT_Offset offset) const override
                            { return getArrayValue_t<fpreal32>(a,offset); }
    bool                getFA64(UT_ValArray<fpreal64> &a,
                                GT_Offset offset) const override
                            { return getArrayValue_t<fpreal64>(a,offset); }
    bool                getUA8(UT_ValArray<uint8> &a,
                                GT_Offset offset) const override
                            { return getArrayValue_t<uint8>(a,offset); }
    bool                getIA8(UT_ValArray<int8> &a,
                                GT_Offset offset) const override
                            { return getArrayValue_t<int8>(a,offset); }
    bool                getIA16(UT_ValArray<int16> &a,
                                GT_Offset offset) const override
                            { return getArrayValue_t<int16>(a,offset); }
    bool                getIA32(UT_ValArray<int32> &a,
                                GT_Offset offset) const override
                            { return getArrayValue_t<int32>(a,offset); }
    bool                getIA64(UT_ValArray<int64> &a,
                                GT_Offset offset) const override
                            { return getArrayValue_t<int64>(a,offset); }
    /// @}

    const uint8     *get(GT_Offset i, uint8 *store, int sz) const override
                        { return GT_DataArray::get(i, store, sz); }
    const int8      *get(GT_Offset i, int8 *store, int sz) const override
                        { return GT_DataArray::get(i, store, sz); }
    const int16     *get(GT_Offset i, int16 *store, int sz) const override
                        { return GT_DataArray::get(i, store, sz); }
    const int32     *get(GT_Offset i, int32 *store, int sz) const override
                        { return getTuple_t(i, store, sz); }
    const int64     *get(GT_Offset i, int64 *store, int sz) const override
                        { return getTuple_t(i, store, sz); }
    const fpreal16  *get(GT_Offset i, fpreal16 *store, int z) const override
                        { return GT_DataArray::get(i, store, z); }
    const fpreal64  *get(GT_Offset i, fpreal64 *store, int z) const override
                        { return getTuple_t(i, store, z); }
    const fpreal32  *get(GT_Offset idx, fpreal32 *store, int z) const override
    {
        if (z == 3 && myV3.isValid())
        {
            UT_Vector3  v = myV3.get(getDataOffset(idx));
            store[0] = v.x();
            store[1] = v.y();
            store[2] = v.z();
            return store;
        }
        if (myF.isValid())
        {
            GA_Offset   o = getDataOffset(idx);
            for (int i = 0; i < z; ++i)
                store[i] = myF.get(o, i);
            return store;
        }
        return getTuple_t(idx, store, z);
    }

    /// Enlarge a bounding box with values
    bool computeMinMax(fpreal64 *min, fpreal64 *max) const override;

    /// @{
    /// Optimized filling methods
    void doImport(GT_Offset idx, uint8 *data, GT_Size size) const override;
    void doImport(GT_Offset idx, int8 *data, GT_Size size) const override;
    void doImport(GT_Offset idx, int16 *data, GT_Size size) const override;
    void doImport(GT_Offset idx, int32 *data, GT_Size size) const override;
    void doImport(GT_Offset idx, int64 *data, GT_Size size) const override;
    void doImport(GT_Offset idx, fpreal16 *data, GT_Size size) const override;
    void doImport(GT_Offset idx, fpreal32 *data, GT_Size size) const override;
    void doImport(GT_Offset idx, fpreal64 *data, GT_Size size) const override;
    void doImportArray(
                GT_Offset idx, UT_ValArray<fpreal16> &data) const override;
    void doImportArray(
                GT_Offset idx, UT_ValArray<fpreal32> &data) const override;
    void doImportArray(
                GT_Offset idx, UT_ValArray<fpreal64> &data) const override;
    void doImportArray(GT_Offset idx, UT_ValArray<uint8> &data) const override;
    void doImportArray(GT_Offset idx, UT_ValArray<int8> &data) const override;
    void doImportArray(GT_Offset idx, UT_ValArray<int16> &data) const override;
    void doImportArray(GT_Offset idx, UT_ValArray<int32> &data) const override;
    void doImportArray(GT_Offset idx, UT_ValArray<int64> &data) const override;
    void doFillArray(uint8 *data, GT_Offset start, GT_Size length,
                     int tuple_size, int stride) const override;
    void doFillArray(int8 *data, GT_Offset start, GT_Size length,
                     int tuple_size, int stride) const override;
    void doFillArray(int16 *data, GT_Offset start, GT_Size length,
                     int tuple_size, int stride) const override;
    void doFillArray(int32 *data, GT_Offset start, GT_Size length,
                     int tuple_size, int stride) const override;
    void doFillArray(int64 *data, GT_Offset start, GT_Size length,
                     int tuple_size, int stride) const override;
    void doFillArray(fpreal16 *data, GT_Offset start, GT_Size length,
                     int tuple_size, int stride) const override;
    void doFillArray(fpreal32 *data, GT_Offset start, GT_Size length,
                     int tuple_size, int stride) const override;
    void doFillArray(fpreal64 *data, GT_Offset start, GT_Size length,
                     int tuple_size, int stride) const override;
    void doFillVec3BBox(fpreal32 *data,
                GT_Offset start, GT_Size length,
                UT_BoundingBoxF &bbox, int tsize, int stride) override;
    void doFillVec3BBox(fpreal64 *data,
                GT_Offset start, GT_Size length,
                UT_BoundingBoxD &bbox, int tsize, int stride) override;
    void doFillQuantizedArray(uint8 *data,
                GT_Offset start, GT_Size length,
                int tuple_size, int stride,
                fpreal black, fpreal white) const override;
    void doExtendedQuantizedFill(uint8 *data,
                GT_Offset start, GT_Size length,
                int tuple_size, int nrepeats, int stride,
                fpreal black, fpreal white) const override;
    void doFillArrayAttr(UT_Array<uint8> &data, UT_Array<int> &sizes,
                     GT_Offset start, GT_Size length) const override;
    void doFillArrayAttr(UT_Array<int8> &data, UT_Array<int> &sizes,
                     GT_Offset start, GT_Size length) const override;
    void doFillArrayAttr(UT_Array<int16> &data, UT_Array<int> &sizes,
                     GT_Offset start, GT_Size length) const override;
    void doFillArrayAttr(UT_Array<int32> &data, UT_Array<int> &sizes,
                     GT_Offset start, GT_Size length) const override;
    void doFillArrayAttr(UT_Array<int64> &data, UT_Array<int> &sizes,
                     GT_Offset start, GT_Size length) const override;
    void doFillArrayAttr(UT_Array<fpreal16> &data, UT_Array<int> &sizes,
                     GT_Offset start, GT_Size length) const override;
    void doFillArrayAttr(UT_Array<fpreal32> &data, UT_Array<int> &sizes,
                     GT_Offset start, GT_Size length) const override;
    void doFillArrayAttr(UT_Array<fpreal64> &data, UT_Array<int> &sizes,
                     GT_Offset start, GT_Size length) const override;
    /// @}

    /// @private - This method relies on knowledge of the internal
    /// implementation.  It's only public for threading efficiency.
    GA_Offset           getDataOffset(GT_Offset offset) const
                        {
                            if (myAttributeOwner == GA_ATTRIB_DETAIL)
                                return GA_Offset(0);

                            GA_Offset gaoff = myOffsets(offset);
                            if (myOffsetOwner == GA_ATTRIB_VERTEX &&
                                    myOffsetOwner != myAttributeOwner)
                            {
                                    if (myAttributeOwner == GA_ATTRIB_POINT)
                                    {
                                        gaoff = myGdp->vertexPoint(gaoff);
                                    }
                                    else
                                    {
                                        UT_ASSERT(myAttributeOwner ==
                                                GA_ATTRIB_PRIMITIVE);
                                        gaoff = myGdp->vertexPrimitive(gaoff);
                                    }
                            }
                            return gaoff;
                        }

protected:
    /// GT_GEOAutoNormalArray has no attribute yet when calling constructor.
    GT_GEOElementArray(const GU_ConstDetailHandle &gdp,
        const GT_GEOOffsetList &offsets,
        GA_AttributeOwner offset_owner);

    void        initAttribute(const GA_Attribute *attrib);
    void        makeInvalid();

    template <typename T> inline T
    getValue_t(GT_Offset offset, int idx) const
                {
                    GA_Offset            si = getDataOffset(offset);
                    T                    val;

                    if (myTuple && myTuple->get(myAttribute, si, val, idx))
                        return val;
                    return 0;
                }

    template <typename T> inline const T *
    getTuple_t(GT_Offset offset, T *store, int size) const
    {
        GA_Offset       si = getDataOffset(offset);
        if (myTuple && myTuple->get(myAttribute, si, store, size))
            return store;
        return NULL;
    }

    template <typename T> inline bool
    getArrayValue_t( UT_ValArray<T> &val, GT_Offset offset) const
                {
                    GA_Offset            si = getDataOffset(offset);

                    if (myNumericArray &&
                            myNumericArray->get(myAttribute, si, val))
                        return true;
                    return false;
                }


    GT_Type             mapTypeInfo(GA_TypeInfo type, int tsize) const;

    GU_ConstDetailHandle                 myGdh;
    const GU_Detail                     *myGdp;
    GT_GEOOffsetList                     myOffsets;
    const GA_Attribute                  *myAttribute;
    const GA_AIFTuple                   *myTuple;
    const GA_AIFStringTuple             *mySTuple;
    const GA_AIFSharedStringTuple       *mySSTuple;
    const GA_AIFNumericArray            *myNumericArray;
    const GA_AIFSharedStringArray       *mySSArray;
    const GA_AIFSharedDictTuple         *mySDictTuple;
    const GA_AIFSharedDictArray         *mySDictArray;
    GA_AttributeOwner                    myOffsetOwner; // What type of offsets
    GA_AttributeOwner                    myAttributeOwner;      // Type of data
    GA_ROHandleF                         myF;
    GA_ROHandleD                         myF64;
    GA_ROHandleI                         myI;
    GA_ROHandleID                        myI64;
    GA_ROHandleV3                        myV3;
    GA_ROHandleV3D                       myV364;
    GA_ROHandleFA                        myFA;
    GA_ROHandleDA                        myFA64;
    GA_ROHandleIA                        myIA;
    GA_ROHandleIDA                       myIA64;
    GT_Storage                           myStorage;
    int                                  myTupleSize;
};

/// This class is specific to managing a detached, auto-generated
/// normal attribute, when no point, vertex, attrib_owner, or offset_owner
/// normals are present on the original detail.
class GT_API GT_GEOAutoNormalArray : public GT_GEOElementArray
{
public:
    GT_GEOAutoNormalArray(
        const GU_ConstDetailHandle &gdp,
        GA_AttributeOwner attrib_owner,
        const GT_GEOOffsetList &offsets,
        GA_AttributeOwner offset_owner,
        float cusp_angle);

    int64 getMemoryUsage() const override
    { return sizeof(*this); }


    void updateGeoDetail(
        const GU_ConstDetailHandle &dtl,
        const char *name,
        GT_Owner attrib_scope,
        const int expected_size) override;
private:
    void createAttribute();

    int64 myPDataId;
    int64 myTopologyDataId;
    int64 myPrimitiveListDataId;
    const float myCuspAngle;
    const GA_AttributeOwner myAttribOwner;

    GA_ATINumericUPtr myAttributeHolder;
};

#endif