GEO/GEO_Vertex.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:
 *      Cristin Barghiel
 *      Side Effects Software Inc.
 *      20 Maud St.
 *      Toronto, Ontario,  M5V 2M5
 *      Canada
 *      416-366-4607
 *
 * NAME:        Geometry Library (C++)
 *
 * COMMENTS:
 *      The vertex class. As opposed to GEO_Points, all vertices are unique.
 *
 * WARNING: Try to avoid using the assignment operator '=' because it is
 *          shallow in the attribute component!
 *
 */

#ifndef __GEO_Vertex_H__
#define __GEO_Vertex_H__

#include "GEO_API.h"
#include <GB/GB_Vertex.h>
#include <GB/GB_Attribute.h>
#include "GEO_Point.h"

class GEO_Detail;

class GEO_API GEO_Vertex : public GB_Vertex, public GB_AttributeElem
{
public:
    explicit GEO_Vertex(              GEO_Point *p=0) : GB_Vertex(p) {}
    explicit GEO_Vertex(GEO_Detail *d,GEO_Point *p=0) : GB_Vertex(p)
    { initAttributeData(d); }

    virtual ~GEO_Vertex() { }

    // Avoid using this c-tor because it's dangerously shallow!
    GEO_Vertex(const GEO_Vertex &vtx)
        : GB_Vertex(vtx.getBasePt()), GB_AttributeElem(vtx) {}

    void                 initAttributeData(GEO_Detail *d);
    void                 swapAttributeData(GEO_Vertex &v);

    GEO_Point           *getPt(void) const { return (GEO_Point*)getBasePt(); }

          UT_Vector4    &getPos()
                         {
                             return ((GEO_Point*)getBasePt())->getPos();
                         }
    const UT_Vector4    &getPos() const
                         {
                             return ((const GEO_Point*)getBasePt())->getPos();
                         }
    void                 setPos(const UT_Vector4 &p)
                                { getPt()->setPos(p); }
    void                 setPos(const UT_Vector3 &p, float w=1)
                                { getPt()->setPos(p, w); }
    void                 setPos(fpreal x, fpreal y, fpreal z, fpreal w=1)
                                { getPt()->setPos(x, y, z, w); }

    void                 steal(GEO_Vertex &src)
                         {
                                GB_Vertex::steal(src);
                                getAttrib().steal(src.getAttrib());
                         }

    /// Deprecated in favour of copyAttributeValues()
    void SYS_DEPRECATED  copyAttributeData(const GEO_Vertex *src, int size);
    /// Deprecated in favour of
    /// copyVertex(const GEO_Vertex &, GEO_Point *, const GB_AttributeDict &)
    void SYS_DEPRECATED  copyVertex(const GEO_Vertex *src, GEO_Point *pt,
                                    int avsize);
    /// Deprecated in favour of
    /// copyVertex(const GEO_Vertex &, const GB_AttributeDict &)
    void SYS_DEPRECATED  copyVertex(const GEO_Vertex *src, int avsize);

    /// Copy a vertex and assign a point
    void                 copyVertex(const GEO_Vertex &src, GEO_Point *pt,
                                    const GB_AttributeDict &vertex_dict)
                         {
                             setPt(pt);
                             copyAttributeValues(src, vertex_dict);
                         }
    void                 copyVertex(const GEO_Vertex &src,
                                    const GB_AttributeDict &vertex_dict)
                         {
                             setPt(src.getBasePt());
                             copyAttributeValues(src, vertex_dict); 
                         }
    void                copyVertex(const GEO_Vertex &v,
                                    const GB_AttributeDict &point_dict,
                                    const GB_AttributeDict &vertex_dict,
                                    bool copyP=true)
                        {
                            if (copyP)
                                setPos(v.getPos());
                            getPt()->copyAttributeValues(*(v.getPt()),
                                                        point_dict);
                            copyAttributeValues(v, vertex_dict);
                        }

    // Avoid using operator=() because it's dangerously shallow!
    GEO_Vertex          &operator=(const GEO_Vertex &vtx)
                         {
                             if (this != &vtx)
                             {
                                 setPt(vtx.getBasePt());
                                 getAttrib() = vtx.getAttrib(); // shallow!
                             }
                             return *this;

                         }
    int                  operator==(const GEO_Vertex &vtx) const
                         {
                             // Trivial check to make it simple. Do not change.
                             return this == &vtx;
                         }

private:
    // Nothing.
};

#endif

---