MSS/MSS_PolySplitState.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_PolySplitState.h
 *
 * COMMENTS:
 *      This is a state which allows on-screen splitting of polygons.
 *      The associated SOP is PolySplit.
 */

#ifndef __MSS_PolySplitState_H__
#define __MSS_PolySplitState_H__

#include "MSS_API.h"
#include <UT/UT_Vector3.h>
#include <UT/UT_Vector3Array.h>
#include <UI/UI_Value.h>
#include "MSS_SingleOpBaseState.h"
#include <GEO/GEO_PrimPoly.h>
#include <GQ/GQ_Detail.h>
class BM_View;
class GU_Detail;
class SOP_PolySplit;
class JEDI_View;
class DM_RayIntersect;
class mss_UndoLoop;

class MSS_API MSS_SplitPoint
{
public:
    MSS_SplitPoint() {
                primitive       = 0;
                type            = 0;
                index           = 0;
                percentage      = 0.5f;
                position.assign(0, 0, 0);
    }
    int         primitive;  // index of primitive
    char        type;       // vertex or edge
    int         index;      // index in primitive
    float       percentage; // percentage along edge
    UT_Vector3  position;   // coordinates of point
};

class MSS_API MSS_PSStateFlags
{
public:
    MSS_PSStateFlags() {
                extendfromstart = 0; // add pts. to begin or end of path?
                mousemoving     = 0; // 1 if locating or active
                updatestring    = 0; // do we need to update from SOP?
                updaterefarray  = 1; // do we need to rebuild myPtRefArray?
                validpick       = 0; // was last point picked valid?

                mousebusy       = 0; // is the mouse in use?

    }
    unsigned    extendfromstart :1,
                mousemoving     :1,
                updatestring    :1,
                updaterefarray  :1,
                validpick       :1,

                mousebusy       :1;
};

class MSS_API MSS_PolySplitState : public MSS_SingleOpBaseState
{
    friend class mss_UndoLoop;
public:
    // Class constructor and destructor.
    MSS_PolySplitState(JEDI_View &view, PI_StateTemplate &templ,
                       BM_SceneManager *scene, bool edgeloop);
    virtual ~MSS_PolySplitState(void);

    // This constructor and parameter template list go into the
    // PI_StateTemplate for this state.
    static BM_State     *ourConstructor(BM_View &view, 
                                        PI_StateTemplate &templ,
                                        BM_SceneManager *scene);
    static BM_State     *ourEdgeLoopConstructor(BM_View &view, 
                                        PI_StateTemplate &templ,
                                        BM_SceneManager *scene);

    static PRM_Template  ourTemplateList[];

    // The name and type of this class:
    virtual const char  *className() const;

    virtual void         initializeUI(PRM_Template *templates=0);

    virtual int          matchesNode(OP_Node &node) const;

    // Mouse events are passed on to all visible PI's.
    virtual int          handleMouseEvent(UI_Event *event);

    virtual void         handleOpNodeChange(OP_Node &/*node*/);

    void                 handleOpEvent(OP_Node *node, OP_EventType type,
                                       void *data);
    static void          opEvent(OP_Node *caller, void *callee,
                                 OP_EventType type, void *data);

    int                  handlePickEvent(UI_Event *event);

    int                  handleRapidFireEvent(UI_Event *event);

    virtual int          handleNodeDeleted(OP_Node &node);

    virtual int          getToolboxCount() const;

protected:
    // Enter or exit this state.
    // enter() returns 0 if entered and -1 if not.
    virtual int          enter(BM_SimpleState::BM_EntryType how);
    virtual void         exit (void);

    // Interrupt this state or resume its activity.
    virtual void         interrupt(BM_SimpleState * = 0);
    virtual void         resume   (BM_SimpleState * = 0);

    // Destroy all chosen points and reselect geometry
    virtual void         restart(void);


    virtual int          handleParameterEvent(UI_Event *event);
    // deal with events coming from either the popup menus or the keyboard
    virtual int          handleKeyTypeEvent(UI_Event *event,
                                            BM_Viewport &/*viewport*/);

    // set the state environment depending on whether we're building or not
    virtual void         setBuild(int yesNo);

    // Set-up state for the first time
    virtual void         doGenerate();

    // show current mouse position and split path
    virtual void         doRender(RE_Render *r, short x, short y, int ghost);

private:
    SOP_PolySplit       *getPolySplitSOP(void) const;

    int                  useLocate() { return (int)myFeedbackVal; }
    int                  snapToMidpoint() { return (int)myMidpointSnapVal; }
    int                  snapToPerp() { return (int)myPerpSnapVal; }
    int                  constBias() { return (int)myConstBiasVal; }

    // Given a mouse event figure out the geometry over which we are hovering
    // and connect the node containing that geometry to our node
    bool                 setParentSOP(UI_Event *event);

    GU_Detail           *getInputGdp();
    void                 updateFromSOP();

    // helper functions for render
    void                 renderCurrentEdge(RE_Render *r, int ghost);
    void                 renderPosFeedback(RE_Render *r, int ghost);
    void                 renderSplitPath(RE_Render *r, int ghost);
    void                 renderLoop(RE_Render *r, int ghost);

    void                 showFeedback(int yesNo);
    void                 setMidpointSnap(int yesNo);
    void                 setConstantBias(int yesNo);
    void                 setPerpSnap(int yesNo);

    void                 handleFeedbackChange(UI_Event *event);
    void                 handleConstantBiasChange(UI_Event *event);
    void                 handleMidpointSnapChange(UI_Event *event);
    void                 handlePerpSnapChange(UI_Event *event);

    // picks a point and figures out what primitive it belongs to, whether it
    // is on a vertex or an edge, and the index number
    void                 pickGeoData(UI_Event *event, MSS_SplitPoint &data);

    // find intersection of event ray with edge w. endpoints end1, end2
    // returns 0 if successful
    int                  calculateEdgePos(UI_Event *event, UT_Vector3 &pos, 
                                          UT_Vector3 &end1, UT_Vector3 &end2);
    // given an unfiltered event fills in the position field of data
    void                 calculatePosition(UI_Event *event, 
                                           MSS_SplitPoint &data);

    void                 addPoint(MSS_SplitPoint data);
    void                 delPoint();

    void                 endSplitPath();
    void                 prepareExtend(UT_Vector3 &point);

    // remove all points both from the point list and from the SOP
    void                 deleteAllPoints();

    // recalculates the first and last points in the path
    void                 updateEndpoints();

    void                 formatPointString(char *point, MSS_SplitPoint data);
    static void          extendString(UT_String &str, UT_String ext, 
                                      int from_end);
    void                 removeString(UT_String &str, int from_end);

    //float                editString(UT_String &str);

    // set floor and display options
    void                 applyStateSettings();
    // restore old settings (before entering state)
    void                 undoStateSettings();

    // builds our ray intersect tree using our input geometry
    void                 buildRayIntersect();

    void                 handleQuitState(UI_Event *event);

private:

    // a list of all the points chosen either by clicking in the viewer
    // or through the PolySplit SOP dialog
    UT_Vector3Array      myPointList;

    // a list of all the points chosen, as displayed in the SOP dialog
    UT_String            myPointsString;

    // the next potential point obtained from the mouse position
    MSS_SplitPoint       myNextPoint;

    // first and last points in the path (depending on the direction in which
    // we are building the path)
    UT_Vector3           myFirstPoint;
    UT_Vector3           myLastPoint;
    float                myLastBias; // the last percentage used

    MSS_PSStateFlags     myFlags;

    UI_Value             mySelFinishedValue;

    // since most of the things happen on mouseup, we need to know what
    // was the last button pressed
    short                myLastMouseDown;
    bool                 myPickStarted;

    BM_State::BM_GenerateMode   myLastGenMode;

    UI_Value             myFeedbackVal; // show feedback checkbox
    UI_Value             myConstBiasVal;        // use constant bias for edges
    UI_Value             myMidpointSnapVal;     // snap to midpoint checkbox
    UI_Value             myPerpSnapVal; // snap to perp checkbox

    DM_RayIntersect     *myRayIntersect;
    GQ_Detail           *myGqd;
    
    bool                 myWeCausedRewire;

    bool                 myEdgeLoopState;
    bool                 myLoopGenerate;
    bool                 myUpdateRayIntersect;
    float                myBias;

    // This node represents the geometry over which our mouse is
    // hovering. It includes footprinted nodes. Used only for the
    // Edgeloop state
    int                  myPickedNode;
};

#endif

---