GB/GB_Attribute.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.
 *
 * Produced by:
 *      Mark Elendt
 *      Side Effects Software Inc.
 *      20 Maud St.
 *      Toronto, Ontario,  M5V 2M5
 *      Canada
 *      416-366-4607
 *
 * NAME:        Geometry Library (C++)
 *
 * COMMENTS:
 *      This contains the class definition for attributes.
 *      The size passed in is the size in bytes of the attribute.
 *      STRING types are stored as a fixed length array, not as pointers
 *      to strings.  However, the string must still be null terminated.
 *
 *
 * COMMON ATTRIBUTE NAMES:
 * (see also GEO_Standard_Attributes in GEO_Detail)
 *      N       vector          Normals (point or primitive)
 *      Dclr    3*float         Display color (for wireframe)
 *      Ca      3*float         Ambient color
 *      Cd      3*float         Diffuse color
 *      Cs      3*float         Specular color
 *      Ct      3*float         Transmit color
 *      Ce      3*float         Emittence color
 *      Ct      1*float         Transparency
 *      Mat     32*char         Material reference (name of material)
 *      UV      2*float         Texture coordinates (tuple)
 *      UVW     3*float         Texture coordinates (triple)
 *      Dopt    GB_DrawOpt      Type of feedback, eg w/ or w/o hull, CVs, wire
 *      Lod     1*float         Level of detail
 *      v       vector          Velocity of point/primitive
 *      Rest    3*float         Rest position for a point: X Y Z
 *
 */

#ifndef __GB_Attribute_h__
#define __GB_Attribute_h__

#include "GB_API.h"
#include <UT/UT_LinkList.h>
#include <UT/UT_PtrArray.h>

#include "GB_AttributeDefines.h"
#include "GB_AttributeDict.h"
#include "GB_AttributeElem.h"
#include "GB_AttributeTable.h"

class UT_IStream;
class UT_StringArray;

/// Definition of a geometry attribute
class GB_API GB_Attribute : public UT_LinkNode 
{
public:
     GB_Attribute(const char *n, int s, GB_AttribType t, const void *def);
     GB_Attribute(const char *n, int s, GB_AttribType t, GB_AttribTypeInfo f,
                  const void *def);
    ~GB_Attribute();

    void initialize(const char *n, int s, GB_AttribType t, GB_AttribTypeInfo f,
                    const void *def);
    void setDefault( const void *def );

    /// Return the name of the attribute
    const char          *getName()      const { return myName; }

    /// @{
    /// Return the size (in @b bytes) of the attribute
    /// @warning  The size of the attribute is the size in @b bytes that the
    ///     attribute data requires.
    /// @note Due to memory alignment issues on some processors, the allocated
    ///     size may be larger than the size required.  Please be aware of this.
    int                  getSize()      const { return mySize; }
    int                  getAllocSize() const
                             { return alignSizeWithWord(mySize); }
    /// @}

    /// Return the type of the attribute
    GB_AttribType        getType()      const { return myType; }
    /// Return the extended type information for the attribute
    GB_AttribTypeInfo    getTypeInfo()  const { return myTypeInfo; }
    /// Return a pointer to the default data (may be NULL)
    const void          *getDefault()   const { return myDefValue; }

    /// Change the name of the attribute
    /// @warning This does @b not check for duplicate names
    void                 rename(const char *newname);

    /// Set the type of the attribute.
    void                 setType(GB_AttribType t)       { myType = t; }
    /// Set extended type information
    void                 setTypeInfo(GB_AttribTypeInfo t)   { myTypeInfo = t; }

    /// @{
    /// Save/load string index table values
    int                  saveIndexValues(ostream &os, int binary) const;
    bool                 loadIndexValues(UT_IStream &is);
    /// @}

    /// Add or return an existing index of a string.
    /// @see GB_AttribType
    int                  addIndex(const char *label);

    /// Similar to addIndex(), this method adds a string to the shared string
    /// table, returning the index of the string.  You should only set the
    /// @c check_dups flag to @c false if you are positive the label doesn't
    /// already exist in the string table (or will be calling
    /// removeRedundantIndex() after the fact.
    int                  addString(const char *label, bool check_dups=true);

    /// @{
    /// Add multiple strings to the string table.  You should only set the @c
    /// check_dups flag to @c false if you are positive that there are no
    /// duplicates in the string list @b and there are no duplicate entries in
    /// the list itself.  If an integer array is passed in, the indices
    /// associated with each string will be set.
    /// The method returns the number of strings added.
    size_t               addStrings(const UT_StringArray &strings,
                                    bool check_duplicates=true,
                                    int *string_ids=NULL);
    size_t               addStrings(const UT_StringList &strings,
                                    bool check_duplicates=true,
                                    int *string_ids=NULL);
    /// @}

    /// Renames a string from one value to another.
    void                 renameIndex(int idx, const char *label);
    /// Removes a string from the index table.  This may adjust the index
    /// values of other strings.  The attribute values will @b not be adjusted
    /// automatically.
    int                  destroyIndex(const char *label)
                         {
                             return destroyIndex(getIndex(label));
                         }
    /// Removes the string with the given index.  This may adjust the index
    /// values of other strings.  The attribute values will @b not be adjusted
    /// automatically.
    int                  destroyIndex(int index);
    /// Remove @b all strings from the index table.  Attribute values will @b
    /// not be adjusted automatically.
    void                 clearIndex(void);
    /// Remove duplicate entries in the index table
    void                 removeRedundantIndex(void);
    /// Return the number of strings in the index table
    int                  getIndexSize(void) const { return myIndexSize; }

    /// Find the index of a given string.  Returns -1 if no string is found
    int                  getIndex(const char *label) const;
    /// Return the string at the given index.  This function may return NULL.
    const char          *getIndex(int idx) const
                         {
                             return (idx < myIndexSize && idx >= 0) ?
                                        myIndexArray[idx] : 0;
                         }

    /// @private Merging index attributes is available for the merge() operation
    int                  mergeIndex(const GB_Attribute *atr);

    /// @private Merging index attributes is available for the merge() operation
    /// The following method simply appends the source's string table to ours.
    int                  mergeIndexByAppending(const GB_Attribute *atr);

    /// @private Used to perform byte alignment of buffers
    static inline int    alignSizeWithWord(int size)
                         {
                            if ((size & (GB_ATTRIB_ALIGN_SIZE-1)) != 0)
                                size += GB_ATTRIB_ALIGN_SIZE -
                                        (size & (GB_ATTRIB_ALIGN_SIZE-1));
                            return size;
                         }

protected:
    friend class GB_AttributeDict;

private:
    void                 grow(unsigned int addedsize);
    void                 shrink( unsigned int removedsize );
    void                 growIndexArray(size_t by_how_much=1);
    
    char                 *myName;
    int                   mySize;
    GB_AttribType         myType;
    GB_AttribTypeInfo     myTypeInfo;
    void                 *myDefValue;   // Default value for attribute
    char                **myIndexArray;
    int                   myIndexSize;
};

#endif

---