MSS/MSS_FaceState.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_FaceState.h
 *
 * COMMENTS:
 *      This is a curve state which allows on-screen editting.
 *
 */

#ifndef __MSS_FaceState_H__
#define __MSS_FaceState_H__

#include "MSS_API.h"
#include <UT/UT_Vector4.h>
#include <UT/UT_Vector4Array.h>
#include <MPI/MPI_CurvePoint.h>
#include <MPI/MPI_FacePointParser.h>
#include <MPI/MPI_CurveSnapInput.h>
#include "MSS_SingleOpBaseState.h"

class BM_View;
class SOP_Curve;
class JEDI_View;

class MSS_API MSS_FaceStateFlags
{
public:
    MSS_FaceStateFlags() {
                freehand        = 0;
                tempcurve       = 0;
                extendfromstart = 0;
                updateinputs    = 0;
    }
    unsigned    freehand        :1,     // use freehand mouse commands
                tempcurve       :1,     // show temporary point
                extendfromstart :1,     // continue from first point
                updateinputs    :1;     // true if input changed while we were
                                        // not building (update needed later)
};

class MSS_API MSS_FaceState : public MSS_SingleOpBaseState
{
public:
    // Class constructor and destructor.
    MSS_FaceState(JEDI_View &view, PI_StateTemplate &templ,
                  BM_SceneManager *scene, const char *cursor);
    virtual ~MSS_FaceState(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;

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

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

    // Check if we have to do anything if this node is deleted.  Return -1 if
    // we can't handle it, 0 otherwise.
    virtual int          handleNodeDeleted(OP_Node &node);

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


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

    // Decide whether you're building the curve now or not:
    virtual void         setBuild(int yesNo);

    // Handle a change-of-face event
    virtual void         doGenerate();

    // Render that part of yourself that is not a handle and not a gdp:
    virtual void         doRender(RE_Render *r, short x, short y, int ghost);

    int                  curveClosed() { return (int)myFaceClosedVal; }

    // Intersects a ray with prim and returns the u value and the ray hit
    // position if successful.  Returns false if unsuccessful.
    bool                 intersectRay(GU_Primitive *prim, UT_Vector3 &ray_orig,
                                      UT_Vector3 &ray_dir, UT_Vector3 &pos, 
                                      float &u_real);

    // Options that are set when this state is entered / exited.
    void                 applyStateSettings();
    void                 undoStateSettings();

private:
    void                 updatePrompt();

    SOP_Curve           *getCurveSOP(void) const 
        { return (SOP_Curve *)BM_SingleOpState::getNode(); }

    // If a node_id is given get that node's gdp; otherwise get the
    // input node's gdp (which is usually what we want, since 
    // we can only reference geometry from the input)
    const GU_Detail     *getReferenceGdp(int node_id = -1);

    void                 updatePointsFromSOP();
    void                 updateFromSOP();

    // In the following functions, p points to an array of size 
    // DM_VALUE_DIMENSION containing information about the point
    void                 addPoint(float *p);
    void                 delPoint();

    
    // Tries to insert a point at the intersection between the ray
    // indicated by the given origin and direction and the curve.
    // The rays should be in object coordinates.
    bool                 insertPoint(UT_Vector3 &ray_orig, 
                                     UT_Vector3 &ray_dir);

    // Moves all the points which are indirectly relative to index by
    // the amount indicated by delta. This function assumes that the
    // coordinate string has not changed in any way, just its interpretation.
    void                 updateDependentPoints(const UT_Vector4 &delta,
                                      int index = 0);

    // Change SOP coordinate string to empty.  Usually waits to be notified
    // that SOP changed before updating state parameters which depend on SOP;
    // however, if update_points is true then it updates everything right away.
    void                 deleteAllPoints(bool update_points = false);

    void                 drawTempCurve(float *p);
    void                 endCurve();
    void                 prepareExtendFace(float *p);

    // calculates how much of the curve is displayed by the SOP
    void                 calcValidIndex();
    // recalculates the first and last points in the curve
    void                 updateEndpoints();

    // get curve point PI index (since we need to closely control when it
    // should be displayed) -- should return -1 if PI not found
    int                  getPointPIIdx();

    // convert all geometry references to their corresponding coordinates
    void                 convertAllReferences();

    // convert all relative points to their corresponding coordinates
    void                 convertAllRelatives();

    // handle changes in myFaceClosedVal
    void                 handleOpenCloseChange(UI_Event *event);

    // reset state parameters to defaults
    void                 resetState();

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

    // the parser is responsible for all string manipulations
    MPI_FacePointParser      myParser;
    
    MPI_CurveSnapInput       myInputMgr;

    // the index of the last point in myPointList that makes a valid
    // face. (while myValidIndex != myPointList.entries()-1 part of
    // the face is degenerate)
    int                      myValidIndex;

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

    // first and last points in the curve (depending on the direction in which
    // we are building the curve)
    UT_Vector4               myFirstPoint;
    UT_Vector4               myLastPoint;

    MSS_FaceStateFlags       myFlags;

    // Each checkbox in the menu has a corresponding UI_Value.
    UI_Value                 myRelPointsVal;
    UI_Value                 myFaceClosedVal;
};

#endif

---