MSS/MSS_JoinSelector.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:
 *      Magdalena Georgescu
 *      Side Effects Software Inc
 *      477 Richmond Street West
 *      Toronto, Ontario
 *      Canada   M5V 3E7
 *      416-504-9876
 *
 * NAME:        MSS_JoinSelector.h ( Direct Manipulation Library, C++)
 *
 * COMMENTS:
 *      Custom selector for the Join SOP.
 *      WARNING: This selector uses the dangerous overrideSelectionType
 * method, which means you should always use it with the MSS_JoinState to
 * ensure your selection buttons are disabled.
 */

#ifndef __MSS_JoinSelector_h__
#define __MSS_JoinSelector_h__

#include "MSS_API.h"
#include <UT/UT_RefArray.h>
#include <GU/GU_Detail.h>
#include <OP3D/OP3D_GenericSelector.h>

class GU_SelectResult;
class GEO_Primitive;
class OP_Node;
class OP3D_View;
class UI_Event;

class MSS_API MSS_JoinPrimitive
{
public:
    GEO_Primitive  *prim;

    // The coordinates are used in rendering -- they correspond to
    // uv coordinates of the primitive as it is going to be used
    // in the join (after necessary reverses are applied)
    UT_Vector3      point_in;   // low u, low v (faces: low u)
    UT_Vector3      point_out;  // high u, low v (faces: high u)
    UT_Vector3      point_in2;  // low u, high v (for hulls only)
    UT_Vector3      point_out2; // high u, high v (for hulls only)
    UT_Vector3      midpt_out;  // for hulls (midpoint of high u side)

    UT_String       oppath;     // node to whom the primitive belongs
    int             reverse;    // none, reverse u, swap uv or both
    int             prim_id;    // primitive's id in it's gdp
    int             selinst;    // the selector list instance


    MSS_JoinPrimitive  &operator=(const MSS_JoinPrimitive &info)
                        {
                            if (&info != this)
                            {
                                prim      = info.prim;
                                point_in  = info.point_in;
                                point_out = info.point_out;
                                point_in2 = info.point_in2;
                                point_out2= info.point_out2;
                                midpt_out = info.midpt_out;
                                reverse   = info.reverse;
                                oppath.harden(info.oppath);
                                prim_id   = info.prim_id;
                                selinst   = info.selinst;
                            }

                            return *this;
                        }

    // There should only be one entry per primitive, so we will use
    // the primitive to find if two entries are equal.  Note that we
    // do not want to check the other entries, since they might be
    // different.
    int                 operator==(const MSS_JoinPrimitive &info) const
                        {
                            return prim == info.prim;
                        }

    bool                 load(UT_IStream &is);
    void                 save(ostream &os, int binary);
};

class MSS_API MSS_JoinSelector : public OP3D_GenericSelector
{
public:
    MSS_JoinSelector(OP3D_View &viewer, PI_SelectorTemplate &templ);
    virtual ~MSS_JoinSelector();

    static BM_InputSelector *ourConstructor(BM_View &Viewer,
                                            PI_SelectorTemplate &templ);


    virtual const char  *className() const;

    virtual int          hasLocates() const { return 1; }
    virtual void         doRender(RE_Render *r, short x, short y, int ghost);
    virtual void         generateAllSelectionStrings(UT_String &sel_string,
                                                     bool destroy_selections,
                                                     bool only_one_gdp);

protected:
    virtual void         startSelecting(bool copy_cooked_selection);

    // Generates implicit reverse nodes for the primitives.  The first
    // parameter is the last node added (the current input to the state node)
    virtual void         appendToLastNode(SOP_Node *&input_node,
                                const UT_String &creator_state_name,
                                bool branch_off);

    // If the node is of a recognized type it sets the parameters.
    virtual void         setNodeParameters(OP_Node &new_node);

    virtual void         addToSelection(UI_Event *event,
                                        const char *path, 
                                        int selinst,
                                        GU_SelectResult &geo);

    virtual int          handleMouseEvent(UI_Event *event);
    virtual bool         handleNoPick(UI_Event *event);
    virtual int          handleKeyEvent(UI_Event *event, DM_Viewport &viewport);

    virtual void         handleNodeDeleted(OP_Node &node);

    // This method is called when, for example, the selection stages 
    // are aborted.  The selections are about to be blasted, so clean up.
    virtual void         clearSelections();

    // Save the contents of the selector so later changes can be undone/redone.
    virtual void         saveForUndo();

private:
    SELECTOR_SETUP()

    void                 getObjectXform(const char *oppath, UT_Matrix4 &xform, 
                                bool inverse = false);

    // Calculates the transformation that needs to be applied to the
    // node in order to display properly.
    void                 getRenderXform(const char *oppath, UT_Matrix4 &xform);

    // Change vec to object space from world space or to render space
    // from object space (render space depends on oppath and which
    // object is currently displayed). 
    // is_coord is true for coordinates, and false for vectors.
    void                 xformToObject(const char *oppath, UT_Vector3 &vec, 
                                bool is_coord = true);
    void                 xformToRender(const char *oppath, UT_Vector3 &vec,
                                bool is_coord = true);

    // Functions which render different parts of the scene:
    void                 renderConnectingLines(RE_Render *r, int ghost);
    void                 renderLastClick(RE_Render *r, int ghost);
    void                 renderFaceEdges(RE_Render *r, int ghost);
    void                 renderHullEdges(RE_Render *r, int ghost);

    SOP_Node            *createReverseNode(OP_Node &parent, int rev_type,
                                const UT_String &creator_state_name,
                                bool branch_off);

    // Knot_in is the side of the primitive that we clicked closest to,
    // knot_out is the opposite side.
    void                 processHull(GEO_Primitive *prim, float u_real, 
                            float v_real, bool &use_u, float &knot_in,
                            float &knot_out, int &reverse);
    void                 processFace(GEO_Primitive *prim, float u_real,
                            float &knot_in, float &knot_out, int &reverse);

    // Given the correct primitive and the reverse type recalculate the
    // other members of MSS_JoinPrimitive. Give the index number into the
    // array -- since for hulls we need to keep detail up to date.
    void                 reprocessHull(MSS_JoinPrimitive &hullinfo, 
                            int idx = -1);
    void                 reprocessFace(MSS_JoinPrimitive &faceinfo);

    void                 findFaceEndpoints(GEO_Face *face, UT_Vector3 &pos1,
                            UT_Vector3 &pos2);
    void                 findFaceMidpoint(GEO_Face *face, UT_Vector3 &pos);

    // Remove the primitive indicated by prim_idx from our array and
    // from the node's selection. If the primitive does not have an
    // id in the array pass in a pointer to the primitive
    void                 removePrimitive(exint prim_idx, const char *oppath,
                            int selinst, GEO_Primitive *prim = 0);

    void                 nodeRemoved(const char *oppath);

    // Given a type of reverse find the reverse that will result in the
    // opposite 'side' of the primitive being used.
    int                  oppositeSide(int rev_type);

    // Find intersection of ray with primitive
    bool                 findRayIntersection(UI_Event *event,
                            const char *oppath, GEO_Primitive *prim,
                            float &u_real, float &v_real);

    // When a new hull is added extract two curves from the edges in our
    // details, so we can display them.
    void                 extractHullSides(GEO_Primitive *prim, bool use_u,
                            float knot_in, float knot_out, GEO_Face *&side1,
                            GEO_Face *&side2,
                            exint prim_idx = -1);

    bool                 selectingHulls()
                            { return (primMask() & GEO_PrimTypeCompat::GEOHULL) ? true : false; }

    // For hulls calculate the midpoint of the last clicked edge; for faces
    // return the endpoint of the face.
    UT_Vector3           lastClickedPos();


    friend class MSS_JoinSelectorUndo;

    UT_RefArray<MSS_JoinPrimitive>       mySelectedPrims;

    GU_Detail           *myInIsoDetail; // positions on surfaces
    GU_Detail           *myOutIsoDetail;

    UT_Vector3           myCrtPos; // used when locating

    bool                 myWrapFlag;
    bool                 myForceReverseFlag;
};

#endif

---