patchobj.h

Go to the documentation of this file.

//**************************************************************************/
// Copyright (c) 1998-2006 Autodesk, Inc.
// All rights reserved.
// 
// These coded instructions, statements, and computer programs contain
// unpublished proprietary information written by Autodesk, Inc., and are
// protected by Federal copyright law. They may not be disclosed to third
// parties or copied or duplicated in any form, in whole or in part, without
// the prior written consent of Autodesk, Inc.
//**************************************************************************/
// FILE:        patchobj.h
// DESCRIPTION: Defines Patch Mesh Object
// AUTHOR:      Tom Hudson
// HISTORY:     created 21 June 1995
//**************************************************************************/

#pragma once
#include "coreexp.h"
#include "maxheap.h"
#include "maxtypes.h"
#include "mouseman.h"
#include "bitarray.h"
#include "maxapi.h"
#include "objmode.h"
#include "object.h"
#include "istdplug.h"
#include "sbmtlapi.h"
#include "patch.h"
// forward declarations
class IObjParam;
class HitRecord;


extern CoreExport Class_ID patchObjectClassID;

extern HINSTANCE hInstance;

// Named selection set list types for PatchObject
#define NS_PO_VERT 0
#define NS_PO_EDGE 1
#define NS_PO_PATCH 2

// set the default pick box size
#define DEF_PICKBOX_SIZE    4

// These are values for selLevel.
#define PO_OBJECT   0
#define PO_VERTEX   1
#define PO_EDGE     2
#define PO_PATCH    3
#define PO_ELEMENT  4
#define PO_HANDLE   5
#define PO_LEVELS   6

#define CID_EP_BIND CID_USER + 203
#define CID_EP_EXTRUDE  CID_USER + 204
#define CID_EP_BEVEL    CID_USER + 205
#define CID_EP_NORMAL_FLIP  CID_USER + 206
#define CID_CREATE_VERT  CID_USER + 207
#define CID_CREATE_PATCH CID_USER + 208
#define CID_VERT_WELD CID_USER + 209
// CAL-06/02/03: copy/paste tangent. (FID #827)
#define CID_COPY_TANGENT CID_USER + 210
#define CID_PASTE_TANGENT CID_USER + 211

// Flags:
// Disp Result keeps track of "Show End Result" button for this Editable Patch
#define EP_DISP_RESULT 0x0100

// References
#define EP_MASTER_CONTROL_REF 0
#define EP_VERT_BASE_REF 1

class PatchObject;


class EP_BindMouseProc : public MouseCallBack {
    private:
        PatchObject *pobj;
        IObjParam *ip;
        IPoint2 om;
        BitArray knotList;
    
    protected:
        HCURSOR GetTransformCursor();
        BOOL HitAKnot(ViewExp *vpt, IPoint2 *p, int *vert);
        BOOL HitASegment(ViewExp *vpt, IPoint2 *p, int *Seg);

        BOOL HitTest( ViewExp *vpt, IPoint2 *p, int type, int flags, int subType );
        BOOL AnyHits( ViewExp *vpt ) { return vpt->NumSubObjHits(); }       

    public:
        EP_BindMouseProc(PatchObject* spl, IObjParam *i) { pobj=spl; ip=i; }
        int proc( 
            HWND hwnd, 
            int msg, 
            int point, 
            int flags, 
            IPoint2 m );
    };



class EP_BindCMode : public CommandMode {
    private:
        ChangeFGObject fgProc;
        EP_BindMouseProc eproc;
        PatchObject* pobj;
//      int type; // See above

    public:
        EP_BindCMode(PatchObject* spl, IObjParam *i) :
            fgProc((ReferenceTarget*)spl), eproc(spl,i) {pobj=spl;}

        int Class() { return MODIFY_COMMAND; }
        int ID() { return CID_EP_BIND; }
        MouseCallBack *MouseProc(int *numPoints) { *numPoints=2; return &eproc; }
        ChangeForegroundCallback *ChangeFGProc() { return &fgProc; }
        BOOL ChangeFG( CommandMode *oldMode ) { return oldMode->ChangeFGProc() != &fgProc; }
        void EnterMode();
        void ExitMode();
//      void SetType(int type) { this->type = type; eproc.SetType(type); }
    };


class EP_ExtrudeMouseProc : public MouseCallBack {
private:
    MoveTransformer moveTrans;
    PatchObject *po;
    Interface *ip;
    IPoint2 om;
    Point3 ndir;
public:
    EP_ExtrudeMouseProc(PatchObject* o, IObjParam *i) : moveTrans(i) {po=o;ip=i;}
    int proc(HWND hwnd, int msg, int point, int flags, IPoint2 m);
};


class EP_ExtrudeSelectionProcessor : public GenModSelectionProcessor {
protected:
    HCURSOR GetTransformCursor();
public:
    EP_ExtrudeSelectionProcessor(EP_ExtrudeMouseProc *mc, PatchObject *o, IObjParam *i) 
        : GenModSelectionProcessor(mc,(BaseObject*) o,i) {}
};


class EP_ExtrudeCMode : public CommandMode {
private:
    ChangeFGObject fgProc;
    EP_ExtrudeSelectionProcessor mouseProc;
    EP_ExtrudeMouseProc eproc;
    PatchObject* po;

public:
    EP_ExtrudeCMode(PatchObject* o, IObjParam *i) :
        fgProc((ReferenceTarget *)o), mouseProc(&eproc,o,i), eproc(o,i) {po=o;}
    int Class() { return MODIFY_COMMAND; }
    int ID() { return CID_EP_EXTRUDE; }
    MouseCallBack *MouseProc(int *numPoints) { *numPoints=2; return &mouseProc; }
    ChangeForegroundCallback *ChangeFGProc() { return &fgProc; }
    BOOL ChangeFG( CommandMode *oldMode ) { return oldMode->ChangeFGProc() != &fgProc; }
    void EnterMode();
    void ExitMode();
};

class EP_NormalFlipMouseProc : public MouseCallBack {
private:
    PatchObject *po;
    Interface *ip;
    IPoint2 om;
    Point3 ndir;
public:
    EP_NormalFlipMouseProc(PatchObject* o, IObjParam *i) {po=o;ip=i;}
    BOOL HitTest( ViewExp *vpt, IPoint2 *p, int type, int flags, int subType );
    BOOL HitAPatch(ViewExp *vpt, IPoint2 *p, int *pix);
    int proc(HWND hwnd, int msg, int point, int flags, IPoint2 m);
};

class EP_NormalFlipCMode : public CommandMode {
private:
    ChangeFGObject fgProc;
    EP_NormalFlipMouseProc eproc;
    PatchObject* po;

public:
    EP_NormalFlipCMode(PatchObject* o, IObjParam *i) :
        fgProc((ReferenceTarget *)o), eproc(o,i) {po=o;}
    int Class() { return MODIFY_COMMAND; }
    int ID() { return CID_EP_NORMAL_FLIP; }
    MouseCallBack *MouseProc(int *numPoints) { *numPoints=1; return &eproc; }
    ChangeForegroundCallback *ChangeFGProc() { return &fgProc; }
    BOOL ChangeFG( CommandMode *oldMode ) { return oldMode->ChangeFGProc() != &fgProc; }
    void EnterMode();
    void ExitMode();
};


class EP_BevelMouseProc : public MouseCallBack {
private:
    MoveTransformer moveTrans;
    PatchObject *po;
    Interface *ip;
    IPoint2 om;
    
public:
    EP_BevelMouseProc(PatchObject* o, IObjParam *i) : moveTrans(i) {po=o;ip=i;}
    int proc(HWND hwnd, int msg, int point, int flags, IPoint2 m);
};


class EP_BevelSelectionProcessor : public GenModSelectionProcessor {
protected:
    HCURSOR GetTransformCursor();
public:
    EP_BevelSelectionProcessor(EP_BevelMouseProc *mc, PatchObject *o, IObjParam *i) 
        : GenModSelectionProcessor(mc,(BaseObject*) o,i) {}
};


class EP_BevelCMode : public CommandMode {
private:
    ChangeFGObject fgProc;
    EP_BevelSelectionProcessor mouseProc;
    EP_BevelMouseProc eproc;
    PatchObject* po;

public:
    EP_BevelCMode(PatchObject* o, IObjParam *i) :
        fgProc((ReferenceTarget *)o), mouseProc(&eproc,o,i), eproc(o,i) {po=o;}
    int Class() { return MODIFY_COMMAND; }
    int ID() { return CID_EP_BEVEL; }
    MouseCallBack *MouseProc(int *numPoints) { *numPoints=3; return &mouseProc; }
    ChangeForegroundCallback *ChangeFGProc() { return &fgProc; }
    BOOL ChangeFG( CommandMode *oldMode ) { return oldMode->ChangeFGProc() != &fgProc; }
    void EnterMode();
    void ExitMode();
};


class EP_CreateVertMouseProc : public MouseCallBack {
private:        
    PatchObject *po;
    IObjParam *mpIP;        
public:
    EP_CreateVertMouseProc(PatchObject* mod, IObjParam *i) {po=mod;mpIP=i;}
    int proc (HWND hwnd, int msg, int point, int flags, IPoint2 m);
};

class EP_CreateVertCMode : public CommandMode {
private:
    ChangeFGObject fgProc;      
    EP_CreateVertMouseProc proc;
    PatchObject *po;

public:
    EP_CreateVertCMode(PatchObject* mod, IObjParam *i) : 
      fgProc((ReferenceTarget *)mod), proc(mod,i) {po=mod;}
    int Class() { return MODIFY_COMMAND; }
    int ID() { return CID_CREATE_VERT; }
    MouseCallBack *MouseProc(int *numPoints) {*numPoints=1; return &proc;}
    ChangeForegroundCallback *ChangeFGProc() {return &fgProc;}
    BOOL ChangeFG(CommandMode *oldMode) {return oldMode->ChangeFGProc()!= &fgProc;}
    void EnterMode();
    void ExitMode();
};

class EP_CreatePatchMouseProc : public MouseCallBack {
public:
    PatchObject *po;
    IObjParam *mpIP;        
    int verts[4];
    IPoint2 anchor, lastPoint, startPoint;

    EP_CreatePatchMouseProc(PatchObject* mod, IObjParam *i);
    BOOL HitTest( ViewExp *vpt, IPoint2 *p, int type, int flags, int subType );
    BOOL HitAVert(ViewExp *vpt, IPoint2 *p, int& vert);

    int proc(HWND hwnd, int msg, int point, int flags, IPoint2 m );
};

class EP_CreatePatchCMode : public CommandMode {
public:
    ChangeFGObject fgProc;
    PatchObject *po;
    EP_CreatePatchMouseProc proc;

    EP_CreatePatchCMode(PatchObject* mod, IObjParam *i) : 
      fgProc((ReferenceTarget *)mod), proc(mod,i) {po=mod;}
    int Class() { return MODIFY_COMMAND; }
    int ID() { return CID_CREATE_PATCH; }
    MouseCallBack *MouseProc(int *numPoints) {*numPoints=5; return &proc;}
    ChangeForegroundCallback *ChangeFGProc() {return &fgProc;}
    BOOL ChangeFG(CommandMode *oldMode) {return oldMode->ChangeFGProc()!= &fgProc;}
    void EnterMode();
    void ExitMode();
};


class EP_VertWeldMouseProc : public MouseCallBack {
public:
    PatchObject *po;
    IObjParam *mpIP;        
    int fromVert, toVert;
    IPoint2 anchor, lastPoint;

    EP_VertWeldMouseProc(PatchObject* mod, IObjParam *i){po=mod;mpIP=i;}
    BOOL HitTest( ViewExp *vpt, IPoint2 *p, int type, int flags, int subType );
    BOOL HitAVert(ViewExp *vpt, IPoint2 *p, int& vert);

    int proc(HWND hwnd, int msg, int point, int flags, IPoint2 m );
};

class EP_VertWeldCMode : public CommandMode {
public:
    ChangeFGObject fgProc;
    PatchObject *po;
    EP_VertWeldMouseProc proc;

    EP_VertWeldCMode(PatchObject* mod, IObjParam *i) : 
      fgProc((ReferenceTarget *)mod), proc(mod,i) {po=mod;}
    int Class() { return MODIFY_COMMAND; }
    int ID() { return CID_VERT_WELD; }
    MouseCallBack *MouseProc(int *numPoints) {*numPoints=2; return &proc;}
    ChangeForegroundCallback *ChangeFGProc() {return &fgProc;}
    BOOL ChangeFG(CommandMode *oldMode) {return oldMode->ChangeFGProc()!= &fgProc;}
    void EnterMode();
    void ExitMode();
};


/*-------------------------------------------------------------------*/
// CAL-06/02/03: copy/paste tangent modes. (FID #827)

class EP_CopyTangentMouseProc : public MouseCallBack {
    private:
        PatchObject *po;
        IObjParam *ip;

    protected:
        HCURSOR GetTransformCursor();
        HitRecord* HitTest( ViewExp *vpt, IPoint2 *p, int type, int flags );

    public:
        EP_CopyTangentMouseProc(PatchObject* obj, IObjParam *i) { po=obj; ip=i; }
        int proc(
            HWND hwnd, 
            int msg, 
            int point, 
            int flags, 
            IPoint2 m );
    };

class EP_CopyTangentCMode : public CommandMode {
    private:
        ChangeFGObject fgProc;
        EP_CopyTangentMouseProc eproc;
        PatchObject* po;

    public:
        EP_CopyTangentCMode(PatchObject* obj, IObjParam *i) :
            fgProc((ReferenceTarget*)obj), eproc(obj,i) {po=obj;}

        int Class() { return MODIFY_COMMAND; }
        int ID() { return CID_COPY_TANGENT; }
        MouseCallBack *MouseProc(int *numPoints) { *numPoints=1; return &eproc; }
        ChangeForegroundCallback *ChangeFGProc() { return &fgProc; }
        BOOL ChangeFG( CommandMode *oldMode ) { return oldMode->ChangeFGProc() != &fgProc; }
        void EnterMode();
        void ExitMode();
    };

class EP_PasteTangentMouseProc : public MouseCallBack {
    private:
        PatchObject *po;
        IObjParam *ip;

    protected:
        HCURSOR GetTransformCursor();
        HitRecord* HitTest( ViewExp *vpt, IPoint2 *p, int type, int flags );

    public:
        EP_PasteTangentMouseProc(PatchObject* obj, IObjParam *i) { po=obj; ip=i; }
        int proc(
            HWND hwnd, 
            int msg, 
            int point, 
            int flags, 
            IPoint2 m );
    };

class EP_PasteTangentCMode : public CommandMode {
    private:
        ChangeFGObject fgProc;
        EP_PasteTangentMouseProc eproc;
        PatchObject* po;

    public:
        EP_PasteTangentCMode(PatchObject* obj, IObjParam *i) :
            fgProc((ReferenceTarget*)obj), eproc(obj,i) {po=obj;}

        int Class() { return MODIFY_COMMAND; }
        int ID() { return CID_PASTE_TANGENT; }
        MouseCallBack *MouseProc(int *numPoints) { *numPoints=1; return &eproc; }
        ChangeForegroundCallback *ChangeFGProc() { return &fgProc; }
        BOOL ChangeFG( CommandMode *oldMode ) { return oldMode->ChangeFGProc() != &fgProc; }
        void EnterMode();
        void ExitMode();
    };


/*-------------------------------------------------------------------*/

class POPickPatchAttach : 
        public PickModeCallback,
        public PickNodeCallback {
    public:     
        PatchObject *po;
        
        POPickPatchAttach() {po=NULL;}

        BOOL HitTest(IObjParam *ip,HWND hWnd,ViewExp *vpt,IPoint2 m,int flags);
        BOOL Pick(IObjParam *ip,ViewExp *vpt);

        void EnterMode(IObjParam *ip);
        void ExitMode(IObjParam *ip);

        HCURSOR GetHitCursor(IObjParam *ip);

        BOOL Filter(INode *node);
        
        PickNodeCallback *GetFilter() {return this;}

        BOOL RightClick(IObjParam* ip,ViewExp* vpt) { UNUSED_PARAM(ip); UNUSED_PARAM(vpt); return TRUE;}
    };


class SingleRefMakerPatchNode;
class SingleRefMakerPatchMtl;

#pragma warning(push)
#pragma warning(disable:4239)

// The Base Patch class
class PatchObject: public GeomObject, IPatchOps, IPatchSelect, IPatchSelectData, ISubMtlAPI, AttachMatDlgUser {
    friend class PatchObjectRestore;
    friend class POXFormProc;
    friend class POPickPatchAttach;
    public:
        static HWND hSelectPanel, hOpsPanel, hSurfPanel, hSoftSelPanel;
        static BOOL rsSel, rsOps, rsSurf;   // rollup states (FALSE = rolled up)
        static MoveModBoxCMode *moveMode;
        static RotateModBoxCMode *rotMode;
        static UScaleModBoxCMode *uscaleMode;
        static NUScaleModBoxCMode *nuscaleMode;
        static SquashModBoxCMode *squashMode;
        static SelectModBoxCMode *selectMode;
//watje command mode for the bind       
        static EP_BindCMode *bindMode;
//watje command mode for the extrude        
        static EP_ExtrudeCMode *extrudeMode;
        static EP_NormalFlipCMode *normalFlipMode;
        static EP_BevelCMode *bevelMode;
        static EP_CreateVertCMode *createVertMode;
        static EP_CreatePatchCMode *createPatchMode;
        static EP_VertWeldCMode *vertWeldMode;
        // CAL-06/02/03: copy/paste tangent. (FID #827)
        static EP_CopyTangentCMode *copyTangentMode;
        static EP_PasteTangentCMode *pasteTangentMode;

        // for the tessellation controls
        static BOOL settingViewportTess;  // are we doing viewport or renderer
        static BOOL settingDisp;  // are we doing viewport or renderer
        static ISpinnerControl *uSpin;
        static ISpinnerControl *vSpin;
        static ISpinnerControl *edgeSpin;
        static ISpinnerControl *angSpin;
        static ISpinnerControl *distSpin;
        static ISpinnerControl *mergeSpin;
        static ISpinnerControl *matSpin;
        static ISpinnerControl *matSpinSel;
        // General rollup controls
        static ISpinnerControl *weldSpin;
        static ISpinnerControl *targetWeldSpin;
        static ISpinnerControl *stepsSpin;
#ifndef NO_OUTPUTRENDERER
        //3-18-99 watje to support render steps
        static ISpinnerControl *stepsRenderSpin;
#endif // NO_OUTPUTRENDERER
// 7/20/00 TH -- Relax controls
        static ISpinnerControl *relaxSpin;
        static ISpinnerControl *relaxIterSpin;

        static POPickPatchAttach pickCB;
        static BOOL patchUIValid;
        static BOOL opsUIValid;
        static int attachMat;
        static BOOL condenseMat;
        // selection box size 
        static int pickBoxSize;
        // selection box size for target weld 
        static int weldBoxSize;

        // Load reference version
        int loadRefVersion;

        Interval geomValid;
        Interval topoValid;
        Interval texmapValid;
        Interval selectValid;
        ChannelMask validBits; // for the remaining constant channels
        void CopyValidity(PatchObject *fromOb, ChannelMask channels);

        //  inherited virtual methods for Reference-management
        RefResult NotifyRefChanged(Interval changeInt, RefTargetHandle hTarget, PartID& partID, RefMessage message );

        static IObjParam *ip;       
        static PatchObject *editObj;

        PatchMesh patch;
        int patchSelSubType;        // PO_PATCH or PO_ELEMENT

        MasterPointControl  *masterCont;        // Master track controller
        Tab<Control*> vertCont;
        Tab<Control*> vecCont;

        // Remembered info
        PatchMesh *rememberedPatch; // NULL if using all selected patches
        int rememberedIndex;
        int rememberedData;

        // Editing stuff:
        BOOL doingHandles;

        BOOL showMesh;
        BOOL propagate;

        BOOL inExtrude,inBevel, inPatchCreate;

        DWORD epFlags;

        // CAL-06/02/03: copy/paste tangent info. (FID #827)
        BOOL copyTanLength;
        BOOL tangentCopied;
        Point3 copiedTangent;

        // Named selection sets:
        GenericNamedSelSetList hselSet;  // Handle // CAL-06/10/03: (FID #1914)
        GenericNamedSelSetList vselSet;  // Vertex
        GenericNamedSelSetList eselSet;  // Edge
        GenericNamedSelSetList pselSet;  // Patch

        // additonal references
        SingleRefMakerPatchNode* noderef;                  
        SingleRefMakerPatchMtl* mtlref; 

        CoreExport PatchObject();
        CoreExport PatchObject(PatchObject &from);

        CoreExport void PatchObjectInit();  // Constructor helper

        CoreExport ~PatchObject();

        // display functions from BaseObject
        CoreExport virtual bool RequiresSupportForLegacyDisplayMode() const;
        CoreExport virtual bool UpdateDisplay(
            unsigned long renderItemCategories, 
            const MaxSDK::Graphics::MaterialRequiredStreams& materialRequiredStreams, 
            TimeValue t);

        CoreExport PatchObject &operator=(PatchObject &from);

        // Flag methods.
        void SetFlag (DWORD fl, BOOL val=TRUE) { if (val) epFlags |= fl; else epFlags &= ~fl; }
        void ClearFlag (DWORD fl) { epFlags &= (~fl); }
        bool GetFlag (DWORD fl) { return (epFlags&fl) ? TRUE : FALSE; }

        //  inherited virtual methods:

        // From BaseObject
        CoreExport int HitTest(TimeValue t, INode* inode, int type, int crossing, int flags, IPoint2 *p, ViewExp *vpt);
        CoreExport int HitTest(TimeValue t, INode* inode, int type, int crossing, int flags, IPoint2 *p, ViewExp *vpt, ModContext* mc);
        CoreExport int Display(TimeValue t, INode* inode, ViewExp *vpt, int flags);
        CoreExport void Snap(TimeValue t, INode* inode, SnapInfo *snap, IPoint2 *p, ViewExp *vpt);
        CoreExport CreateMouseCallBack* GetCreateMouseCallBack();
        CoreExport RefTargetHandle Clone(RemapDir& remap);
        
        // Gizmo versions:
        CoreExport int Display(TimeValue t, INode* inode, ViewExp *vpt, int flags, ModContext *mc);
        CoreExport void GetWorldBoundBox (TimeValue t, INode * inode, ViewExp* vp, Box3& box, ModContext *mc);

        // NS: New SubObjType API
        CoreExport int NumSubObjTypes();
        CoreExport ISubObjType *GetSubObjType(int i);

        // From Object           
        CoreExport Interval ObjectValidity(TimeValue t);
        CoreExport BOOL GetExtendedProperties(TimeValue t, MSTR &prop1Label, MSTR &prop1Data, MSTR &prop2Label, MSTR &prop2Data);
        CoreExport BOOL PolygonCount(TimeValue t, int& numFaces, int& numVerts);

        // get and set the validity interval for the nth channel
        CoreExport Interval ChannelValidity(TimeValue t, int nchan);
        CoreExport void SetChannelValidity(int i, Interval v);
        CoreExport void InvalidateChannels(ChannelMask channels);
        CoreExport void TopologyChanged(); // mjm - 5.6.99

        // Convert-to-type validity
        CoreExport Interval ConvertValidity(TimeValue t);

        // Deformable object procs  
        virtual int IsDeformable() { return 1; }  
        CoreExport int NumPoints();
        CoreExport Point3 GetPoint(int i);
        CoreExport void SetPoint(int i, const Point3& p);
        CoreExport BOOL IsPointSelected (int i);
        
        CoreExport void PointsWereChanged();
        CoreExport void GetDeformBBox(TimeValue t, Box3& box, Matrix3 *tm=NULL,BOOL useSel=FALSE );
        CoreExport void Deform(Deformer *defProc, int useSel);

        virtual BOOL IsParamSurface() {return TRUE;}
        CoreExport  Point3 GetSurfacePoint(TimeValue t, float u, float v,Interval &iv);

        // Mappable object procs
        virtual int IsMappable() { return 1; }
        virtual int NumMapChannels () { return patch.NumMapChannels (); }
        virtual int NumMapsUsed () { return patch.getNumMaps(); }
        virtual void ApplyUVWMap(int type, float utile, float vtile, float wtile,
            int uflip, int vflip, int wflip, int cap,const Matrix3 &tm,int channel=1) {
                patch.ApplyUVWMap(type,utile,vtile,wtile,uflip,vflip,wflip,cap,tm,channel); }

        CoreExport int CanConvertToType(Class_ID obtype);
        CoreExport Object* ConvertToType(TimeValue t, Class_ID obtype);
        CoreExport void GetCollapseTypes(Tab<Class_ID> &clist,Tab<MSTR*> &nlist);
        CoreExport void FreeChannels(ChannelMask chan);
        CoreExport Object *MakeShallowCopy(ChannelMask channels);
        CoreExport void ShallowCopy(Object* fromOb, ChannelMask channels);
        CoreExport void NewAndCopyChannels(ChannelMask channels);

        CoreExport DWORD GetSubselState();

        // From GeomObject
        CoreExport int IntersectRay(TimeValue t, Ray& ray, float& at, Point3& norm);
        CoreExport void GetWorldBoundBox(TimeValue t, INode *inode, ViewExp* vpt, Box3& box );
        CoreExport void GetLocalBoundBox(TimeValue t, INode *inode, ViewExp* vpt, Box3& box );
        CoreExport int IsInstanceDependent();   // Not view-dependent (yet)
        CoreExport Mesh* GetRenderMesh(TimeValue t, INode *inode, View& view, BOOL& needDelete);

        CoreExport PatchMesh& GetPatchMesh(TimeValue t);
        CoreExport Mesh& GetMesh(TimeValue t);

        // Animatable methods

        CoreExport virtual void DeleteThis();
        virtual void FreeCaches() {patch.InvalidateGeomCache(); }
        virtual Class_ID ClassID() { return Class_ID(PATCHOBJ_CLASS_ID,0); }
        CoreExport BOOL IsSubClassOf(Class_ID classID);
        CoreExport virtual void GetClassName(MSTR& s);
        
        using GeomObject::GetInterface;
        CoreExport void* GetInterface(ULONG id);
        
        // This is the name that will appear in the history browser.
        CoreExport virtual MCHAR *GetObjectName();

        // Controller stuff for animatable points
        int NumSubs()  { return 1; }    // Just tell it about the master point controller
        CoreExport Animatable* SubAnim(int i);
        CoreExport MSTR SubAnimName(int i);
        CoreExport BOOL AssignController(Animatable *control,int subAnim);
        int SubNumToRefNum(int subNum) {return subNum;}
        CoreExport BOOL SelectSubAnim(int subNum);
        CoreExport BOOL HasControllers(BOOL assertCheck=TRUE);

        // Reference methods
        CoreExport void RescaleWorldUnits(float f);
        int NumRefs() {return vertCont.Count() + vecCont.Count() + 1;}  // vert conts + vec conts + master
        CoreExport RefTargetHandle GetReference(int i);
protected:
        CoreExport virtual void SetReference(int i, RefTargetHandle rtarg);
public:
        CoreExport int RemapRefOnLoad(int iref);
        CoreExport void PlugControllersSel(TimeValue t);
        CoreExport void AllocVertContArray(int count);
        CoreExport void AllocVecContArray(int count);
        CoreExport void AllocContArrays(int vertCount, int vecCount);
        CoreExport void ReplaceVertContArray(Tab<Control *> &nc);
        CoreExport void ReplaceVecContArray(Tab<Control *> &nc);
        CoreExport void ReplaceContArrays(Tab<Control *> &vertnc, Tab<Control *> &vecnc);
        CoreExport BOOL PlugVertControl(TimeValue t,int i);
        CoreExport BOOL PlugVecControl(TimeValue t,int i);
        CoreExport void SetVertAnim(TimeValue t, int point, Point3 pt);
        CoreExport void SetVecAnim(TimeValue t, int point, Point3 pt);
        CoreExport void SetVertCont(int i, Control *c);
        CoreExport void SetVecCont(int i, Control *c);

        // IO
        CoreExport IOResult Save(ISave *isave);
        CoreExport IOResult Load(ILoad *iload);

        // PatchObject-specific methods
        CoreExport virtual void UpdatePatchMesh(TimeValue t);
        CoreExport void PrepareMesh(TimeValue t);
        CoreExport Mesh& GetUnrelaxedMesh(TimeValue t); // Ignore relax!
        CoreExport BOOL ShowLattice() { return patch.GetDispFlag(DISP_LATTICE) ? TRUE : FALSE; }
        CoreExport BOOL ShowVerts() { return patch.GetDispFlag(DISP_VERTS) ? TRUE : FALSE; }
        CoreExport void SetShowLattice(BOOL sw) { if(sw) patch.SetDispFlag(DISP_LATTICE); else patch.ClearDispFlag(DISP_LATTICE); }
        CoreExport void SetShowVerts(BOOL sw) { if(sw) patch.SetDispFlag(DISP_VERTS); else patch.ClearDispFlag(DISP_VERTS); }
        CoreExport void SetMeshSteps(int steps);
        CoreExport int GetMeshSteps();
#ifndef NO_OUTPUTRENDERER
        //3-18-99 watje to support render steps
        CoreExport void SetMeshStepsRender(int steps);
        CoreExport int GetMeshStepsRender();
#endif // NO_OUTPUTRENDERER
        CoreExport BOOL Relaxing();     // returns TRUE if Relax && RelaxValue != 0 && RelaxIter != 0
        CoreExport void SetRelax(BOOL v);
        CoreExport void SetRelaxViewports(BOOL v);
        CoreExport void SetRelaxValue(float v);
        CoreExport void SetRelaxIter(int v);
        CoreExport void SetRelaxBoundary(BOOL v);
        CoreExport void SetRelaxSaddle(BOOL v);
        BOOL GetRelax() { return patch.GetRelax(); }
        BOOL GetRelaxViewports() { return patch.GetRelaxViewports(); }
        float GetRelaxValue() { return patch.GetRelaxValue(); }
        int GetRelaxIter() { return patch.GetRelaxIter(); }
        BOOL GetRelaxBoundary() { return patch.GetRelaxBoundary(); }
        BOOL GetRelaxSaddle() { return patch.GetRelaxSaddle(); }

        CoreExport void SetShowInterior(BOOL si);
        CoreExport BOOL GetShowInterior();

        CoreExport void SetUsePatchNormals(BOOL usePatchNorm);
        CoreExport BOOL GetUsePatchNormals();

        CoreExport void SetAdaptive(BOOL sw);
        CoreExport BOOL GetAdaptive();
        CoreExport void SetViewTess(TessApprox tess);
        CoreExport TessApprox GetViewTess();
        CoreExport void SetProdTess(TessApprox tess);
        CoreExport TessApprox GetProdTess();
        CoreExport void SetDispTess(TessApprox tess);
        CoreExport TessApprox GetDispTess();
        CoreExport BOOL GetViewTessNormals();
        CoreExport void SetViewTessNormals(BOOL use);
        CoreExport BOOL GetProdTessNormals();
        CoreExport void SetProdTessNormals(BOOL use);
        CoreExport BOOL GetViewTessWeld();
        CoreExport void SetViewTessWeld(BOOL weld);
        CoreExport BOOL GetProdTessWeld();
        CoreExport void SetProdTessWeld(BOOL weld);
        CoreExport void InvalidateMesh();
        CoreExport void InvalidateRelaxedMesh();

        // Editable patch stuff follows...
        CoreExport virtual void BeginEditParams( IObjParam  *ip, ULONG flags,Animatable *prev);
        CoreExport virtual void EndEditParams( IObjParam *ip, ULONG flags,Animatable *next);
        CoreExport int GetSubobjectLevel();
        CoreExport int GetSubobjectType();  // returns PO_PATCH for PO_ELEMENT level
        CoreExport void SetSubobjectLevel(int level);
        CoreExport void ActivateSubobjSel(int level, XFormModes& modes );
        CoreExport int SubObjectIndex(HitRecord *hitRec);
        CoreExport void GetSubObjectTMs(SubObjAxisCallback *cb,TimeValue t,INode *node,ModContext *mc);
        CoreExport void ShowEndResultChanged (BOOL showEndResult);
        CoreExport void GetSubObjectCenters(SubObjAxisCallback *cb,TimeValue t,INode *node,ModContext *mc);
        int NeedUseSubselButton() { return 0; }
        CoreExport void SelectSubComponent( HitRecord *hitRec, BOOL selected, BOOL all, BOOL invert );
        CoreExport void ClearSelection(int selLevel);
        CoreExport void SelectAll(int selLevel);
        CoreExport void InvertSelection(int selLevel);
        
        CoreExport void PatchSelChanged();
        CoreExport void InvalidateSurfaceUI();
        CoreExport void InvalidateOpsUI();

        CoreExport void ChangeRememberedPatch(int type);
        CoreExport void ChangeSelPatches(int type);
        CoreExport int RememberPatchThere(HWND hWnd, IPoint2 m);
        CoreExport void SetRememberedPatchType(int type);
        CoreExport void ChangeRememberedVert(int type);
        CoreExport void ChangeSelVerts(int type);
        CoreExport int RememberVertThere(HWND hWnd, IPoint2 m);
        CoreExport void SetRememberedVertType(int type);

        // Generic xform procedure.
        CoreExport void XFormVerts( POXFormProc *xproc, TimeValue t, Matrix3& partm, Matrix3& tmAxis );

        // Specialized xform for bezier handles
        CoreExport void XFormHandles( POXFormProc *xproc, TimeValue t, Matrix3& partm, Matrix3& tmAxis, int handleIndex );

        // Affine transform methods     
        CoreExport void Move( TimeValue t, Matrix3& partm, Matrix3& tmAxis, Point3& val, BOOL localOrigin=FALSE );
        CoreExport void Rotate( TimeValue t, Matrix3& partm, Matrix3& tmAxis, Quat& val, BOOL localOrigin=FALSE );
        CoreExport void Scale( TimeValue t, Matrix3& partm, Matrix3& tmAxis, Point3& val, BOOL localOrigin=FALSE );

        // The following is called before the first Move(), Rotate() or Scale() call
        CoreExport void TransformStart(TimeValue t);

        // The following is called after the user has completed the Move, Rotate or Scale operation and
        // the undo object has been accepted.
        CoreExport void TransformFinish(TimeValue t);       

        // The following is called when the transform operation is cancelled by a right-click and the undo
        // has been cancelled.
        CoreExport void TransformCancel(TimeValue t);       

        CoreExport ObjectState Eval(TimeValue t);

        BOOL SupportsNamedSubSels() {return TRUE;}
        CoreExport void ActivateSubSelSet(MSTR &setName);
        CoreExport void NewSetFromCurSel(MSTR &setName);
        CoreExport void RemoveSubSelSet(MSTR &setName);
        CoreExport void SetupNamedSelDropDown();
        CoreExport int NumNamedSelSets();
        CoreExport MSTR GetNamedSelSetName(int i);
        CoreExport void SetNamedSelSetName(int i,MSTR &newName);
        CoreExport void NewSetByOperator(MSTR &newName,Tab<int> &sets,int op);
        CoreExport BOOL GetUniqueSetName(MSTR &name);
        CoreExport int SelectNamedSet();
        CoreExport void NSCopy();
        CoreExport void NSPaste();
        CoreExport GenericNamedSelSetList &GetSelSet();

        CoreExport void RefreshSelType();
        CoreExport void SetNumSelLabel();
        CoreExport void SetSelDlgEnables();
        CoreExport void SetOpsDlgEnables();
        CoreExport void SetSurfDlgEnables();
        CoreExport void SetSoftSelDlgEnables( HWND hSoftSel = NULL );

        // from AttachMatDlgUser
        CoreExport int GetAttachMat();
        CoreExport void SetAttachMat(int value);
        CoreExport BOOL GetCondenseMat();
        CoreExport void SetCondenseMat(BOOL sw);

        CoreExport void DoAttach(INode *node, PatchMesh *attPatch, bool & canUndo);
        CoreExport void SetTessUI(HWND hDlg, TessApprox *tess);
        // 'interactive' in the following records Undo information, displays prompts, notifies
        // dependents and redraws when TRUE
        CoreExport void DoDeleteSelected(BOOL interactive=TRUE);
        CoreExport void DoBreak(BOOL interactive=TRUE);
        CoreExport void ResolveTopoChanges();
        CoreExport void DeletePatchParts(BitArray &delVerts, BitArray &delPatches);
        // Animated point stuff:
        CoreExport void CreateContArrays();
        CoreExport void SynchContArrays();
        // Materials
        CoreExport int GetSelMatIndex();
        CoreExport void SetSelMatIndex(int index);
        CoreExport void SelectByMat(int index,BOOL clear);
        // Smoothing
        CoreExport DWORD GetSelSmoothBits(DWORD &invalid);
        CoreExport DWORD GetUsedSmoothBits();
        CoreExport void SelectBySmoothGroup(DWORD bits,BOOL clear);
        CoreExport void SetSelSmoothBits(DWORD bits,DWORD which);
        // Subdivision / addition
        CoreExport void SetPropagate(BOOL sw);
        CoreExport BOOL GetPropagate();
        CoreExport void DoPatchAdd(int type);
        CoreExport void DoSubdivide(int level);
        CoreExport void DoPatchDetach(int copy, int reorient);
        // Welding
        CoreExport void DoVertWeld();
        CoreExport void DoVertWeld(int fromVert, int toVert);
        CoreExport void DoEdgeWeld();
        // CAL-06/02/03: copy/paste tangent. (FID #827)
        CoreExport void StartCopyTangentMode();
        CoreExport void StartPasteTangentMode();
        CoreExport void StartPasteTangent();
        CoreExport void EndPasteTangent();

        CoreExport BOOL CopyTangent(int vec);
        CoreExport BOOL PasteTangent(int vec);
//watje
        //hide and unhide stuff
        CoreExport void DoHide(int type) ;
        CoreExport void DoUnHide();
        CoreExport void DoPatchHide();
        CoreExport void DoVertHide();
        CoreExport void DoEdgeHide();
//watje hook stuff
        CoreExport void DoAddHook(int vert1, int seg1) ;
        CoreExport void DoRemoveHook() ;
//watje bevel and extrusion stuff
        CoreExport void DoExtrude(TimeValue t) ;
        CoreExport void BeginExtrude(TimeValue t);  
        CoreExport void EndExtrude (TimeValue t, BOOL accept=TRUE);     
        CoreExport void Extrude( TimeValue t, float amount, BOOL useLocalNorm );

        CoreExport void DoFlipNormals(int patchIndex = -1);
        CoreExport void DoUnifyNormals();
        
        CoreExport void DoBevel(TimeValue t) ;
        CoreExport void BeginBevel(TimeValue t);    
        CoreExport void EndBevel (TimeValue t, BOOL accept=TRUE);       
        CoreExport void Bevel( TimeValue t, float amount, BOOL smoothStart, BOOL smoothEnd );

        // CAL-04/23/03: patch smooth (FID #1914)
        CoreExport void DoPatchSmooth(int type);

        // methods for creating new vertices and patches
        CoreExport void CreateVertex(Point3 pt, int& newIndex);
        CoreExport void CreatePatch(int vertIndx1,int vertIndx2,int vertIndx3);
        CoreExport void CreatePatch(int vertIndx1,int vertIndx2,int vertIndx3,int vertIndx4);

        // patch select and operations interfaces, JBW 2/2/99
        CoreExport void StartCommandMode(patchCommandMode mode);
        CoreExport void ButtonOp(patchButtonOp opcode);

// LAM: added 9/3/00
    // UI controls access
        CoreExport void GetUIParam (patchUIParam uiCode, int & ret);
        CoreExport void SetUIParam (patchUIParam uiCode, int val);
        CoreExport void GetUIParam (patchUIParam uiCode, float & ret);
        CoreExport void SetUIParam (patchUIParam uiCode, float val);
        bool Editing () { return (ip && (editObj==this)) ? TRUE : FALSE; }

        CoreExport DWORD GetSelLevel();
        CoreExport void SetSelLevel(DWORD level);
        CoreExport void LocalDataChanged();

        CoreExport BitArray GetVecSel();
        CoreExport BitArray GetVertSel();
        CoreExport BitArray GetEdgeSel();
        CoreExport BitArray GetPatchSel();
        
        CoreExport void SetVecSel(BitArray &set, IPatchSelect *imod, TimeValue t);
        CoreExport void SetVertSel(BitArray &set, IPatchSelect *imod, TimeValue t);
        CoreExport void SetEdgeSel(BitArray &set, IPatchSelect *imod, TimeValue t);
        CoreExport void SetPatchSel(BitArray &set, IPatchSelect *imod, TimeValue t);

        CoreExport GenericNamedSelSetList& GetNamedVecSelList();
        CoreExport GenericNamedSelSetList& GetNamedVertSelList();
        CoreExport GenericNamedSelSetList& GetNamedEdgeSelList();
        CoreExport GenericNamedSelSetList& GetNamedPatchSelList();

        // Vertex Color Support...
        CoreExport Color GetVertColor(int mp=0, bool *differs=NULL);
        CoreExport void SetVertColor(Color clr, int mp=0);
        CoreExport void SelectVertByColor(VertColor clr, int deltaR, int deltaG, int deltaB, BOOL add, BOOL sub, int mp=0);
        // and patch-level vertex color support
        CoreExport Color GetPatchColor(int mp=0, bool *differs=NULL);
        CoreExport void SetPatchColor(Color clr, int mp=0);

        // ISubMtlAPI methods:
        CoreExport MtlID GetNextAvailMtlID(ModContext* mc);
        CoreExport BOOL HasFaceSelection(ModContext* mc);
        CoreExport void SetSelFaceMtlID(ModContext* mc, MtlID id, BOOL bResetUnsel = FALSE);
        CoreExport int GetSelFaceUniqueMtlID(ModContext* mc);
        CoreExport int GetSelFaceAnyMtlID(ModContext* mc);
        CoreExport int GetMaxMtlID(ModContext* mc);
//watje new patch mapping
        CoreExport void ChangeMappingTypeLinear(BOOL linear);

        // CAL-04/23/03: Shrink/Grow, Edge Ring/Loop selection. (FID #1914)
        CoreExport void ShrinkSelection(int type);
        CoreExport void GrowSelection(int type);
        CoreExport void SelectEdgeRing();
        CoreExport void SelectEdgeLoop();

        CoreExport void SelectOpenEdges();
        CoreExport void DoCreateShape();

// soft selection support
//
        CoreExport int  UseEdgeDists();
        CoreExport void SetUseEdgeDists( int useSoftSelections );
        CoreExport int  UseSoftSelections();
        CoreExport void SetUseSoftSelections( int useSoftSelections );
        CoreExport void InvalidateVertexWeights();
        // CAL-05/06/03: toggle shaded faces display for soft selection. (FID #1914)
        CoreExport void ToggleShadedFaces();

        CoreExport void UpdateVertexDists();
        CoreExport void UpdateEdgeDists( );
        CoreExport void UpdateVertexWeights();

        CoreExport Point3 VertexNormal( int vIndex ); 

};

#pragma warning(pop)

CoreExport ClassDesc* GetPatchObjDescriptor();

// Helper classes used internally for undo operations

class POModRecord: public MaxHeapOperators {
    public:
        virtual ~POModRecord(){}
        virtual BOOL Restore(PatchObject *po, BOOL isUndo)=0;
        virtual BOOL Redo(PatchObject *po)=0;
        virtual DWORD Parts()=0;                // Flags of parts modified by this
    };

class PatchObjectRestore : public RestoreObj {
    public:
        POModRecord *rec;       // Modification record
        PatchObject  *po;

        PatchObjectRestore(PatchObject *po, POModRecord *rec);
        virtual ~PatchObjectRestore();

        void Restore(int isUndo);
        void Redo();
        int Size() { return 1; }
        void EndHold() {po->ClearAFlag(A_HELD);}
        MSTR Description() { return MSTR(_M("PatchObject restore")); }
    };

class SingleRefMakerPatchNode : public SingleRefMaker{
    public:
        HWND hwnd;
        PatchObject *po;
        SingleRefMakerPatchNode() {hwnd = NULL; po = NULL;}
        ~SingleRefMakerPatchNode() { }
        RefResult NotifyRefChanged( Interval changeInt,RefTargetHandle hTarget, 
        PartID& partID, RefMessage message );
    };

class SingleRefMakerPatchMtl : public SingleRefMaker{
    public: 
        HWND hwnd;
        PatchObject *po;
        SingleRefMakerPatchMtl() {hwnd = NULL; po = NULL;}
        ~SingleRefMakerPatchMtl() { }
        RefResult NotifyRefChanged( Interval changeInt,RefTargetHandle hTarget, 
        PartID& partID, RefMessage message );
};

// Command ID for the dynamic spline quad menu entry
#define ID_PATCH_MENU 1333

const DWORD kPatchActions = 0x34fe4c77;
const DWORD kPatchActionsContext = 0x34fe4c77;