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

#ifndef __GT_DAIndirect__
#define __GT_DAIndirect__

#include "GT_API.h"
#include "GT_DAInherit.h"

#include <UT/UT_StringArray.h> // required by GT_IMPL_INHERIT_ARRAY()
#include <UT/UT_ValArray.h>

/// @brief An array to handle indirect references (i.e. shared items)
///
/// This class takes two GT_DataArrays.  The indirect array should be an array
/// of integers which are used to perform indirect lookup into the shared data
/// array.
/// For example: @code
///     GT_DataArray    VertexList =  [ 1, 4, 2, 3 ]
///     GT_DataArray    &PointAttributes;
///     GT_DAIndirect   attribs(VertexList, PointAttributes);
/// @endcode
/// This allows the point attributes to be referenced by vertex number.
class GT_API GT_DAIndirect : public GT_DAInherit
{
public:
    /// Default constructor
    GT_DAIndirect()
        : myIndirect()
        , GT_DAInherit()
    { }
    /// Convenience constructor
    GT_DAIndirect(const GT_DataArrayHandle &indirect,
                  const GT_DataArrayHandle &data,
                  bool flatten_nested = false)
        : myIndirect()
        , GT_DAInherit()
    {
        init(indirect, data, flatten_nested);
    }
    /// Copy constructor
    GT_DAIndirect(const GT_DAIndirect &src)
        : myIndirect()
        , GT_DAInherit()
    {
        init(src.myIndirect, src.myData, true);
    }
    /// Destructor
    ~GT_DAIndirect() override;

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

    bool                isValid() const override
                    { return myIndirect && myData &&
                             myIndirect->isValid() && myData->isValid(); }
    void                updateGeoDetail(const GU_ConstDetailHandle &dtl,
                                        const char *attrib_name,
                                        GT_Owner attrib_owner,
                                        const int expected_size) override;

    /// Initialize data from an indirect array of indices and a data array
    void                init(const GT_DataArrayHandle &indirect,
                             const GT_DataArrayHandle &data,
                             bool flatten_nested);

    const GT_DataArrayHandle    &getIndirect() const { return myIndirect; }
    int64                        getDataId() const override;

    GT_Size                      itemSize(GT_Offset offset) const override
                                    { return myData->itemSize(myIndirect->getI64(offset)); }
    GT_Size                      getTotalArrayEntries() const override
                                    {
                                        GT_Size sum = 0;
                                        for (GT_Size off = 0; off < myIndirect->entries(); ++off)
                                            sum += myData->itemSize(myIndirect->getI64(off));
                                        return sum;
                                    }

    bool isSameIndirection(const GT_DataArray &base) const override
                {
                    auto *other = dynamic_cast<const GT_DAIndirect *>(&base);
                    return other
                           && other->getIndirect()->getDataId()
                                      == getIndirect()->getDataId()
                           && myData->isSameIndirection(*other->myData);
                }

    static int getUnmapThreshold();

    GT_IMPL_INHERIT_ARRAY(getIndirect, myIndirect->entries())

private:
    /// Map the requested offset to the offset in my data
    inline GT_Offset    getIndirect(GT_Offset offset) const
                            { return myIndirect->getI64(offset); }

    GT_DataArrayHandle          myIndirect;
};

#endif