MSS/MSS_PolyKnitState.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:
 *      Ondrej Kos
 *      Side Effects Software Inc
 *      477 Richmond Street West
 *      Toronto, Ontario
 *      Canada   M5V 3E7
 *      416-504-9876
 *
 * NAME:        MSS_PolyKnitState.h
 *
 * COMMENTS:
 *      This is a state which allows on-screen knitting of polygons.
 *      The associated SOP is PolyKnit.
 */

#ifndef __MSS_PolyKnitState_H__
#define __MSS_PolyKnitState_H__

#include "MSS_API.h"
#include <UT/UT_HashTable.h>
#include <UT/UT_Vector3.h>
#include <UI/UI_Value.h>
#include "MSS_SingleOpBaseState.h"

class GB_PointRefArray;
class GEO_Point;
class GU_Detail;
class SOP_Node;
class SOP_PolyKnit;
class JEDI_View;
class GUI_DetailLook;
class GUI_DisplayOption;
class BM_View;
class RE_Render;
class mss_NodeEntry;

// MSS_PolyKnitPoint contains the information needed for each
// point in our list.
class MSS_API MSS_PolyKnitPoint
{
public:
    bool operator==(const MSS_PolyKnitPoint &p)
    {
        return (oppath          == p.oppath       &&
                local_index     == p.local_index  &&
                merged_index    == p.merged_index &&
                shared_edge     == p.shared_edge  &&
                meta_edge       == p.meta_edge    &&
                cache_index     == p.cache_index  &&
                point_list      == p.point_list);
    }
    const MSS_PolyKnitPoint     &operator=(const MSS_PolyKnitPoint &p)
    {
        oppath.harden(p.oppath);
        local_index = p.local_index;
        merged_index = p.merged_index;
        shared_edge = p.shared_edge;
        meta_edge = p.meta_edge;
        cache_index = p.cache_index;
        point_list = p.point_list;

        return *this;
    }

    UT_String   oppath;         // full path to op and possibly Dop data
    int         local_index;    // index in owner's gdp
    int         merged_index;   // index in merged gdp
    int         shared_edge;    // shares edge with previous point?
    bool        meta_edge;      // This pt and prev pt are meta edge

    UT_Vector3  tmp_pos;        // This is a temporary position used for 
                                // locating, since we don't add the point's
                                // gdp to our table right away.  The points
                                // in our point list have their positions 
                                // obtained directly from the geo point each
                                // time.  (This is because the gdp above us 
                                // can change and thus throw our cached pos
                                // out of sync)

    int         cache_index;    // points to the local_index entry of the
                                // point whose list with whom we have already
                                // computed the path.  This acts as a cache
                                // in case the user deletes and re-selects the
                                // same point, we don't want to re-compute the
                                // same path again.  -1 means that we have
                                // no path cached.  The local_index is used
                                // because they have to be in the same gdp
                                // for them to have a path at all.

    // Unfortunately we can't store the pointers to the points because they
    // can change, therefore, we may only keep their point numbers
    UT_IntArray point_list;
};

// Flags for the state.
class MSS_API MSS_PolyKnitStateFlags
{
public:
    MSS_PolyKnitStateFlags() {
        validpick       = 0;    // was last picked point valid?
        uselocate       = 1;    // show feedback on current position?

    }
    unsigned    validpick       :1,
                uselocate       :1;

};

class MSS_API MSS_PolyKnitState : public MSS_SingleOpBaseState
{
public:
    // Class constructor and destructor.
    MSS_PolyKnitState(JEDI_View &view, PI_StateTemplate &templ,
                       BM_SceneManager *scene);
    virtual ~MSS_PolyKnitState(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 PRM_Template  ourTemplateList[];

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

    virtual void         initializeUI(PRM_Template *templates=0);

    // 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);

    void                 renderForPicking(RE_Render *r, short x, short y);

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_PolyKnit        *getPolyKnitSOP(void) const
        { return (SOP_PolyKnit *)BM_SingleOpState::getNode(); }

    // helper functions for render
    void                 renderStrip(RE_Render *r, int ghost);
    void                 renderPosFeedback(RE_Render *r, int ghost);
    void                 renderMetaEdge(RE_Render *r, int ghost, 
                                        const UT_IntArray &ptlist,
                                        const char *oppath);

    bool                 pickPoint(UI_Event *event, MSS_PolyKnitPoint &data,
                                   bool nonmeta);

    // helper functions for handling dialog options
    void                 showFeedback(int yesNo);

    void                 handleFeedbackChange(UI_Event *event);

    // given an unfiltered event fills in the fields of a vector
    void                 calculatePosition(UI_Event *event,
                                           UT_Vector3 &pos);

    bool                 validForRender(GUI_DetailLook *detail,
                                        const GUI_DisplayOption &dopt);

    void                 finishBuilding();
    bool                 filterPointListAndConnectOps();
    void                 updateParameters();

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


    void                 updateNodeAndPointInfo(MSS_PolyKnitPoint &data, 
                                                int ptindex,
                                                bool updatesharedflag = true);

    // Updates (calculates) the path information between pt0 and pt1,
    // puts the path in pt0's list.
    void                 updatePath(MSS_PolyKnitPoint &pt0,
                                    MSS_PolyKnitPoint &pt1);

    void                 addPoint(const MSS_PolyKnitPoint &data,
                                  bool updatesharedflag = true);
    void                 deletePoint(const char *oppath);

    // Returns true and the position of the point, otherwise (i.e. the point
    // doesn't exist!) returns false
    bool                 getPos(const MSS_PolyKnitPoint &point, 
                                UT_Vector3 &pos, bool worldpos = true);
    // Transforms the point into world-space using myNodeArray(index).
    void                 xformToWorld(UT_Vector3 &pos, int index);
    // Transforms the point into world-space using the supplied oppath.
    void                 xformToWorld(UT_Vector3 &pos, const char *oppath);

    // Updates the display prompt based on the current number of points
    void                 updatePrompt();

    // Updates our point lists and type lists from the SOP.  This is an
    // expensive operation because we may be building point-ref arrays.
    void                 updateFromSOP(const UT_Vector3 &pos);

    // Adds the points in point_list and the types in type_list to the state.
    void                 addSopPoints(const UT_IntArray &point_array, 
                                  const UT_IntArray &type_list, 
                                  const UT_PtrArray<GU_Detail *> &gdplist, 
                                  const UT_StringArray &oppathlist);

    // Returns true if pos is closer to lastpt than it is to firstpt,
    // otherwise returns false
    bool                 extendForward(const UT_Vector3 &pos, 
                                       const GEO_Point &firstpt,
                                       const GEO_Point &lastpt);

    // Fills the data point with the correct local_index using the sop list
    // and the gdp list
    void                 updatePointIndex(MSS_PolyKnitPoint &data, 
                                  int merged_index,
                                  const UT_PtrArray<GU_Detail *> &gdplist,
                                  const UT_StringArray &oppathlist);

    // Reverses an int array
    void                 reverseArray(UT_IntArray &arr);

    // Flips primitive types, two triangles go to a quad and vice versa
    void                 flipTypes();

    const GU_Detail     *getInputGdp(const SOP_Node *sop, int idx=0);
    const SOP_Node      *getInputSOP();

    // Returns true if the given node is implicit, otherwise returns false
    bool                 isImplicit(const SOP_Node *node);

    // Adds a node to our table and array (only if it doesn't already exist)
    void                 addNode(const char *oppath);
    void                 removeNode(int index);

    // TODO: For debug only
    void                 dumpPointList();

    // a list of all the points chosen either by clicking in the viewer
    // or through the PolyKnit SOP dialog
    UT_RefArray<MSS_PolyKnitPoint>      myPointList;

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

    // The "live" point under the mouse. Always in world coordinates.
    UT_Vector3                          myNextPoint;

    MSS_PolyKnitStateFlags              myStateFlags;

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

    UI_Value                            mySelFinishedValue;

    UI_Value                            myFeedbackVal;  // show feedback

    UT_PtrArray<mss_NodeEntry *>        myNodeArray;
    UT_HashTable                        myNodeTable;

    // The kinds of primitives we are building, each entry will be a 
    // a primitive after the sop cooks
    UT_IntArray                         myTypeArray;
    int                                 myNumVerts;

    BM_State::BM_GenerateMode           myLastGenMode;

    // This falg says whether or not we read in the points from the SOP
    // in reverse order (and thus should output the results in reverse order
    // or risk reversing the normals)
    bool                                myReverseOutput;
};

#endif

---