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

#ifndef __GT_GEOElementId__
#define __GT_GEOElementId__

#include "GT_API.h"
#include "GT_DataArray.h"
#include "GT_GEOSupport.h"
#include <GU/GU_DetailHandle.h>
#include <UT/UT_Assert.h>

/// A representation of an offsets list as a GT data array.  If we're given a
/// list of vertex offsets, we can also provide the primitive/point id's.  This
/// is done for primitives like quadrics.
class GT_API GT_GEOElementId : public GT_DataArray
{
public:
    GT_GEOElementId(const GU_ConstDetailHandle &gdp,
                    const GT_GEOOffsetList &offsets,
                    GA_AttributeOwner index_type,
                    bool from_vertex);
    ~GT_GEOElementId() override;

    const char         *className() const override { return "GT_GEOElementId"; }
    
    /// @{
    /// Query methods defined on GT_DataArray
    GT_Storage          getStorage() const override
                        {
                            return myOffsets.is32Bit() ? GT_STORE_INT32
                                                        : GT_STORE_INT64;
                        }
    GT_Size             getTupleSize() const override { return 1; }
    GT_Type             getTypeInfo() const override { return GT_TYPE_HIDDEN; }
    GT_Size             entries() const override { return myOffsets.entries(); }
    int64               getMemoryUsage() const override;
    /// @}

    /// @{
    /// Access methods
    int64               getI64(GT_Offset offset, int =0) const override
                            { return getOffset(offset); }
    uint8               getU8(GT_Offset offset, int idx) const override
                            { return getOffset(offset); }
    int32               getI32(GT_Offset offset, int idx) const override
                            { return getOffset(offset); }
    fpreal16            getF16(GT_Offset offset, int idx=0) const override
                            { return getOffset(offset); }
    fpreal32            getF32(GT_Offset offset, int idx=0) const override
                            { return getOffset(offset); }
    fpreal64            getF64(GT_Offset offset, int idx=0) const override
                            { return getOffset(offset); }

    GT_String           getS(GT_Offset, int) const override
                            { return UT_StringHolder::theEmptyString; }
    GT_Size             getStringIndexCount() const override            { return -1; }
    GT_Offset           getStringIndex(GT_Offset, int) const override   { return -1; }
    void                getIndexedStrings(UT_StringArray &,
                                UT_IntArray &) const override   { }
    GT_Size                             getDictIndexCount() const override                              { return -1; }
    GT_Offset                   getDictIndex(GT_Offset, int) const override             { return -1; }
    void                getIndexedDicts(UT_Array<UT_OptionsHolder> &,
                                UT_IntArray &) const override   { }
    /// @}

protected:
    // specialization for filling int32/int64
    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;

    /// @{
    /// Call base class to handle other data
    void         doFillArray(uint8 *data, GT_Offset start, GT_Size length,
                        int tuple_size, int stride) const override
                 {
                     GT_DataArray::doFillArray(data, start, length,
                             tuple_size, stride);
                 }
    void         doFillArray(fpreal16 *data, GT_Offset start, GT_Size length,
                        int tuple_size, int stride) const override
                 {
                     GT_DataArray::doFillArray(data, start, length,
                             tuple_size, stride);
                 }
    void         doFillArray(fpreal32 *data, GT_Offset start, GT_Size length,
                        int tuple_size, int stride) const override
                 {
                     GT_DataArray::doFillArray(data, start, length,
                             tuple_size, stride);
                 }
    void         doFillArray(fpreal64 *data, GT_Offset start, GT_Size length,
                        int tuple_size, int stride) const override
                 {
                     GT_DataArray::doFillArray(data, start, length,
                             tuple_size, stride);
                 }
    /// @}

private:
    int64               getOffset(GT_Offset offset) const
                        {
                            GA_Offset   gaoff = myOffsets(offset);
                            if (myVertexMap)
                            {
                                if (myOwner == GA_ATTRIB_POINT)
                                    gaoff = myGdp->vertexPoint(gaoff);
                                else
                                    gaoff = myGdp->vertexPrimitive(gaoff);
                            }
                            return gaoff;
                        }
    GU_ConstDetailHandle         myGdh;
    const GU_Detail             *myGdp;
    GT_GEOOffsetList             myOffsets;
    GA_AttributeOwner            myOwner;
    bool                         myVertexMap;
};

#endif