GU_VertexSelection.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:        GU_VertexSelection (C++)
 *
 * COMMENTS:
 *      Vertex selection.
 *
 */

#ifndef __GU_VertexSelection_h__
#define __GU_VertexSelection_h__

#include "GU_API.h"
#include "GU_Selection.h"
#include "GU_OrderedIndexGroup.h"

class GU_API GU_VertexSelection : public GU_Selection
{
public:
    GU_VertexSelection(const GA_VertexGroup *vtx_group = NULL);
    ~GU_VertexSelection() override;

    bool                 select(const GU_Detail &gd,
                                uint prim_id, uint v_num, uint,
                                GU_SelectionRule rule,
                                GU_SelectResult &added,
                                GU_SelectFinishData *&finish_data) override;
    bool                 selectFinish(
                                const GU_Detail &gd,
                                GU_SelectionRule rule,
                                GU_SelectResult &added,
                                GU_SelectFinishData *finish_data) override;
    bool                 testSelect(const GU_Detail &gd,
                                    uint prim_id, uint v_num, uint,
                                    bool accept_existing,
                                    bool accept_new,
                                    GU_SelectResult &result) const override;

    bool                 selectionPoint(const GU_SelectResult &added,
                                        UT_Vector3 &xsect) const override;
    bool                 selectionPoint(const GU_SelectResult &added,
                                        UT_Vector3 rayorig, 
                                        UT_Vector3 &raydir, 
                                        UT_Vector3 &xsect,
                                        bool       &normal,
                                        UT_Vector3 &vector,
                                        bool accurate, 
                                        float *u, float *v) const override;

    void                 assign(const GU_Detail &gd,
                                const GU_Selection &sel) override;
    
    bool                 selectAll(const GU_Detail &gd) override; 
    bool                 toggleAll(const GU_Detail &gd) override;
    
    bool                 validate(const GU_Detail &gd) override;

    bool                 selectBoundary(
                                const GU_Detail &gd,
                                bool checkuv,
                                const UT_StringHolder &uvattribname) override;
    bool                 growSelection(
                                const GU_Detail &gd,
                                bool checkuv,
                                const UT_StringHolder &uvattribname) override;
    bool                 shrinkSelection(
                                const GU_Detail &gd,
                                bool checkuv,
                                const UT_StringHolder &uvattribname) override;

    bool                 filterByPrimitiveMask(
                                const GU_Detail &gd,
                                const GA_PrimitiveTypeMask &mask) override;

    bool                 modifyPoint(const GU_Detail &gd, GA_Offset ptoff, 
                                     GU_ModifyType type) override;
    
    bool                 modifyVertex(const GU_Detail &gd, GA_Offset vtxoff, 
                                      GU_ModifyType type) override;
    
    bool                 modifyPrimitive(const GU_Detail &gd, GA_Offset primoff,
                                         GU_ModifyType type) override;
    
    bool                 modifyEdge(const GU_Detail &gd, const GA_Edge &edge, 
                                    const GEO_Primitive *prim, 
                                    GU_ModifyType type) override;
    
    bool                 modifyBreakpoint(const GU_Detail &gd, 
                                          const GA_Breakpoint &bkp, 
                                          GU_ModifyType type) override;

    const GA_PointGroup     *points(const GU_Detail &gd) const override;
    const GA_PrimitiveGroup *primitives(const GU_Detail &gd) const override;
    const GA_VertexGroup    *vertices(const GU_Detail &gd) const override;
    const GA_EdgeGroup      *edges(const GU_Detail &gd) const override;
    const GA_BreakpointGroup    *breakpoints(
                                        const GU_Detail &gd) const override;
    const GA_Group              *mainGroup(const GU_Detail &gd) const override
                                    { return vertices(gd); }

    bool                 hasVertexIndex(GA_Index index) const override; 

    
    void                 clear() override;
    void                 clearAndDestroy() override;

    GA_Size              entries()   const override;

    bool                 getBoundingBox(
                                const GU_Detail &gd,
                                UT_BoundingBox &bbox) const override;
    bool                 getBoundingBox(
                                const GU_Detail &gd,
                                UT_BoundingBox &bbox,
                                const UT_Matrix4R &transform) const override;

    bool                 getBoundingBoxUV(
                                const GU_Detail &gd,
                                UT_BoundingBox &bbox,
                                const char *name,
                                int isvertex) const override;

    GA_GroupType         classType() const override;

    GU_Selection         *clone() override;

    bool                 modifyMatchingGroup(const GU_Detail &gd,
                                             const GA_Group &group,
                                             GU_SelectionRule rule) override;

    int64 getMemoryUsage(bool inclusive) const override
    {
        int64 mem = inclusive ? sizeof(*this) : 0;
        mem += GU_Selection::getMemoryUsage(false);
        mem += myVertices.getMemoryUsage(false);
        return mem;
    }

private:
    GU_VertexSelection(const GU_VertexSelection &s);

    bool                saveElements(UT_JSONWriter &w) const override;
    bool                loadElements(UT_JSONParser &p) override;

    friend struct VertexLoader;
    typedef GU_OrderedIndexGroup<GA_Index> OrderedVertexGroup;
    OrderedVertexGroup          myVertices;
};

#endif