IPainterInterface.h

Go to the documentation of this file.

#pragma once

#include "object.h"

/********************************************************************************

  IPainterInterface contains all the interfaces to let a plugin interact with
  Maxs Paint system

  Basically the system consists of 2 components the IPainterInterface and IPainterCanvasInterface

  For a plugin to use the paint system it must sub class of IPainterCanvasInterface_V5 or greater 
  and implement the virtual methods and be a sub class of ReferenceTarget.  A canvas is what the 
  painterInterface paints on. Basically  IPainterCanvasInterface_V5 consists of functions to 
  identify the canvas version and functions that are called a as the system paints, basically a 
  start stroke, stroke and endstroke.

  The IPainterInterface is what does all the hit testing against the mesh using a quad tree.  
  Basically it tells the canvas what the stroke looks like.  In addition the canvas can use it
  do additional hit testing not associated with a stroke.

  In its simplest from all that needs to be done is
  
    1.  Subclass your plugin from IPainterCanvasInterface_V5 and ReferenceTarget
    2.  Fill out these virtual methods

        StartStroke() - called when a stroke is started
        PaintStroke()/PaintStroke(<..>) - called as a stroke is going on
        EndStroke() - called when the stroke ends and accepted.
        EndStroke(<...>) - called when the system is set to non interactive mode.
        CancelStroke() - called if a stroke is canceled.
        SystemEndPaintSession() - is called when the painter wants to end a paint session for some reason
        See the header for me description of the parameters

        You also need to add the painter interface to the GetInterface method from ReferenceTarget.  
        Something along the lines below.  This lets the painter set what interfaces the canvas supports.
            
              void* PainterTester::GetInterface(ULONG id)
                {
                switch(id)
                    {
                    case PAINTERCANVASINTERFACE_V5 : return (IPainterCanvasInterface_V5 *) this;
                        break;
                    default: return ReferenceTarget::GetInterface(id);
                    break;
                    }
                }



    3.  In addition to implementing these methods, The plugin needs to hook up to 
        the painterInterface.  Using these functions.  The pointer to the painter 
        can be gotten by using the CreateInstance(REF_TARGET_CLASS_ID,PAINTERINTERFACE_CLASS_ID). 
        Once that pointer is gotten you need to grab a specific version of the painterInterface
        using GetPaintInterface.   See sample below

    
            ReferenceTarget *painterRef = (ReferenceTarge *) GetCOREInterface()->CreateInstance(REF_TARGET_CLASS_ID,PAINTERINTERFACE_CLASS_ID); 
//set it to the correct verion
            if (painterRef)         
                IPainterInterface_V5 *painter = (IPainterInterface_V5 *) painterRef->GetInterface(PAINTERINTERFACE_V5);

        Once you have a valid pointer you need to hook your self up to the Painter using the
        InitializeCallback method.  This is should be done just before you want to start a paint seesion.
        All you are doing is passing a pointer of yourself to the painter system so it knows where 
        to send the messages.  Note yourself to IPainterCanvasInterface since the Painter will 
        interogate you to find out which version of the canvas you are.

            painter->InitializeCallback((ReferenceTarget *) this);

        Once you have called InitializedCallback and are ready to start a paint session you need load up which 
        Nodes you want to paint on.  This is done with InitializeNodes(int flags, Tab<INode*> &nodeList).

                painter->InitializeNodes(0, nodes);

        Then StartPaintSession() is called.  Once this is called everytime the the users drag paints across
        the nodes the Canvas's StartStroke/PaintStroke/EndStroke will get called.
        
                painter->StartPaintSession();

        If the canvas changes the topology or geometry of the painted nodes UpdateMeshes() needs to be called
        so the quad tree gets updated.

                painter->UpdateMeshes(BOOL updatePoitnCache);

        
        Once the canvas is done with the painter it needs to call EndPaintSession() so that all the data can
        be freed and it can be unhooked.  Otherwise the StartStroke/PaintStroke/EndStroke will still be called.

                painter->EndPaintSession();

        You can also bring up the Painters Option dialog using the BringUpOptions().

                painter->BringUpOptions() ;

        In addition there will be some helper functions for gathering points within a stroke and their weigths; and 
        tools for intersecting rays against the quad tree.  See the header for more descriptions.


        See the PaintTester project for a simple implementation of a canvas and interaction with the painter.



*********************************************************************************/


#include "maxheap.h"
#include "iFnPub.h"
#include "icurvctl.h"


#define PAINTERINTERFACE_V5 0x78ffe181
#define PAINTERINTERFACE_V7 0x78ffe182
#define PAINTERINTERFACE_V14 0x78ffe183
#define PAINTERCANVASINTERFACE_V5 0x29ff7ac9
#define PAINTERCANVASINTERFACE_V5_1 0x29ff7ad0
#define PAINTERCANVASINTERFACE_V7 0x1e962374

#define PAINTERINTERFACE_CLASS_ID   Class_ID(0x2f2ef7e9, 0x78ffe181)
#define PAINTERINTERFACE_SUPERCLASS_ID  REF_TARGET_CLASS_ID

#define PAINTERINTERFACEV5_INTERFACE Interface_ID(0x53b4520c, 0x29ff7ac9)

//These are defines used to when mirroring is enabled with point gathering
//a point can be hit by the original brush, the mirror brushed, or both
#define NO_MIRRROR      0
#define MIRRRORED       1
#define MIRRROR_SHARED  2


#define         RINGCOLOR           0x445408e0
#define         NORMALCOLOR         0x445408e1
#define         RINGPRESSEDCOLOR    0x445408e2
#define         NORMALPRESSEDCOLOR  0x445408e3
#define         TRACECOLOR          0x445408e4
#define         GIZMOCOLOR          0x445408e5


#define PRESSURE_AFFECTS_NONE   0
#define PRESSURE_AFFECTS_STR    1
#define PRESSURE_AFFECTS_SIZE   2
#define PRESSURE_AFFECTS_BOTH   3



class IPainterInterface_V5: public MaxHeapOperators
    {
    public:
    
//these are the esswential tools to get you started     
//they cover the basics to get you started



        virtual BOOL  InitializeCallback(ReferenceTarget *canvas) = 0;//tested


        virtual BOOL  InitializeNodes(int flags, Tab<INode*> &nodeList) = 0;//tested


        virtual BOOL  UpdateMeshes(BOOL updatePointGather) = 0;

        virtual BOOL  StartPaintSession() = 0;//tested

        virtual BOOL  EndPaintSession() = 0;//tested


        virtual BOOL  InPaintMode()=0;//tested

        virtual BOOL  BringUpOptions() = 0;//tested


        virtual int *RetrieveTimeList(int &ct) = 0;

//These functions are additional tools to further hit testing and point gathering
//to help with finding points on a mesh that are within the stroke and theoir weights


        virtual BOOL TestHit(
                          IPoint2 mousePos,
                          Point3 &worldPoint, Point3 &worldNormal,
                          Point3 &localPoint, Point3 &localNormal,
                          Point3 &bary,  int &index,
                          INode *node,
                          BOOL &mirrorOn,
                          Point3 &worldMirrorPoint, Point3 &worldMirrorNormal,
                          Point3 &localMirrorPoint, Point3 &localMirrorNormal
                          ) = 0;


        virtual BOOL RandomHit(Point3 &worldPoint, Point3 &worldNormal,
                          Point3 &localPoint, Point3 &localNormal,
                          Point3 &bary,  int &index,
                          float &strFromFalloff, INode *node,
                          BOOL &mirrorOn,
                          Point3 &worldMirrorPoint, Point3 &worldMirrorNormal,
                          Point3 &localMirrorPoint, Point3 &localMirrorNormal,
                          int tabIndex) = 0;


        virtual BOOL RandomHitAlongStroke(Point3 &worldPoint, Point3 &worldNormal,
                          Point3 &localPoint, Point3 &localNormal,
                          Point3 &bary,  int &index,
                          float &strFromFalloff, INode *node,
                          BOOL &mirrorOn,
                          Point3 &worldMirrorPoint, Point3 &worldMirrorNormal,
                          Point3 &localMirrorPoint, Point3 &localMirrorNormal,
                          int tabIndex) = 0;



        virtual BOOL ClearStroke()=0;


        virtual BOOL AddToStroke(IPoint2 mousePos, BOOL rebuildPointGatherData, BOOL updateViewport)=0;

    //These are direct to stroke data lists if you are doing your own point gather
    //Each stroke contains an arrays of data that are used to describe it such as
    //position, str, radius etc.

        virtual int GetStrokeCount() = 0;
        virtual float *GetStrokeStr() = 0;
        virtual float *GetStrokeRadius() = 0;
        virtual Point3 *GetStrokePointWorld() = 0;
        virtual Point3 *GetStrokeNormalWorld() = 0;
        virtual Point3 *GetStrokePointWorldMirror() = 0;
        virtual Point3 *GetStrokeNormalWorldMirror() = 0;
        virtual float *GetStrokePressure() = 0;

        virtual Point3 *GetStrokePointLocal() = 0;
        virtual Point3 *GetStrokeNormalLocal() = 0;
        virtual Point3 *GetStrokePointLocalMirror() = 0;
        virtual Point3 *GetStrokeNormalLocalMirror() = 0;

        virtual IPoint2 *GetStrokeMousePos() = 0;

        virtual BOOL *GetStrokeHitList() = 0;

        virtual Point3 *GetStrokeBary() = 0;
        virtual int *GetStrokeIndex() = 0;

        virtual BOOL *GetStrokeShift() = 0;
        virtual BOOL *GetStrokeCtrl() = 0;
        virtual BOOL *GetStrokeAlt() = 0;

        virtual INode **GetStrokeNode() = 0;
        virtual int *GetStrokeTime() = 0;


        virtual float GetStrFromPoint(Point3 point) = 0;

//These functions let you interogate and set the state of the options dialog


        //these return array of floats one entry for each point on the stroke
         virtual float *GetPredefineStrStrokeData(int &ct)=0;


         virtual float *GetPredefineSizeStrokeData(int &ct)=0;


         //put in access to all the dialog properties


        virtual BOOL  GetBuildNormalData() = 0;

        virtual void  SetBuildNormalData(BOOL enable) = 0;

//These functions deal with the point gather.  The painter can automatically determines the weights
//of points by using the  PointGather


        virtual BOOL  GetEnablePointGather() = 0;

        virtual void  SetEnablePointGather(BOOL enable) = 0;//tested


        virtual BOOL LoadCustomPointGather(int ct, Point3 *points, INode *node) = 0;//tested

        //Once a stroke has started you can retrieve data about you point list such
        //as weigths, str etc.

        virtual float *RetrievePointGatherWeights(INode *node, int &ct) = 0;

        virtual float *RetrievePointGatherStr(INode *node, int &ct) = 0;//tested

        virtual BOOL *RetrievePointGatherIsMirror(INode *node, int &ct) = 0;//tested

        virtual Point3 *RetrievePointGatherPoints(INode *node, int &ct) = 0;//tested
        

        virtual Point3 *RetrievePointGatherNormals(INode *node, int &ct) = 0;


        virtual float *RetrievePointGatherU(INode *node, int &ct) = 0;

        

//functions to get the mirror plane data
//NOTE all mirror function work in world space
        virtual BOOL  GetMirrorEnable() = 0 ;//tested
        virtual void  SetMirrorEnable(BOOL enable) = 0;

        virtual Point3 GetMirrorPlaneCenter() = 0;//tested

        virtual int GetMirrorAxis() = 0;//tested

        virtual void SetMirrorAxis(int dir) = 0;
        virtual float GetMirrorOffset() = 0;//tested
        virtual void  SetMirrorOffset(float offset) = 0;//tested



        virtual int GetTreeDepth() = 0;//tested

        virtual void SetTreeDepth(int depth) = 0;//tested


        virtual BOOL GetUpdateOnMouseUp() = 0;

        virtual void SetUpdateOnMouseUp(BOOL update) = 0;


        virtual int GetLagRate() = 0;

        virtual void SetLagRate(int lagRate) = 0;

//These functions control how the brush behaves


        virtual float GetMinStr() = 0;//tested

        virtual void  SetMinStr(float str) = 0;//tested

        virtual float GetMaxStr() = 0;//tested

        virtual void  SetMaxStr(float str) = 0;//tested


        virtual float GetMinSize() = 0;//tested

        virtual void  SetMinSize(float str) = 0;//tested

        virtual float GetMaxSize() = 0;//tested

        virtual void  SetMaxSize(float str) = 0;//tested


        virtual BOOL  GetAdditiveMode()=0;//tested

        virtual void  SetAdditiveMode(BOOL enable)=0;//tested
        virtual ICurve *GetFalloffGraph()=0;


//These functions allow you to control the display of a stroke
//Colors are stored in the color manager. See the color ID defines at the top


        virtual BOOL  GetDrawRing()=0;//tested

        virtual void  SetDrawRing(BOOL draw)=0;//tested


        virtual BOOL  GetDrawNormal()=0;//tested

        virtual void  SetDrawNormal(BOOL draw)=0;//tested


        virtual BOOL  GetDrawTrace()=0;//tested

        virtual void  SetDrawTrace(BOOL draw)=0;//tested


//These functions deal with the pressure sensitive devices and mimicing pressure sensitivity


        virtual BOOL  GetPressureEnable()=0;//tested

        virtual void  SetPressureEnable(BOOL enable)=0;//tested


        virtual BOOL  GetPressureAffects()=0;//tested

        virtual void  SetPressureAffects(int affect)=0;//tested


        virtual BOOL  GetPredefinedStrEnable()=0;//tested

        virtual void  SetPredefinedStrEnable(BOOL enable)=0;//tested


        virtual BOOL  GetPredefinedSizeEnable()=0;//tested

        virtual void  SetPredefinedSizeEnable(BOOL enable)=0;//tested

        virtual ICurve *GetPredefineSizeStrokeGraph()=0;

        virtual ICurve *GetPredefineStrStrokeGraph()=0;

        virtual float GetNormalScale() = 0;
        virtual void SetNormalScale(float scale) = 0;

        virtual BOOL GetMarkerEnable() = 0;
        virtual void SetMarkerEnable(BOOL on) = 0;
        virtual float GetMarker() = 0;
        virtual void SetMarker(float pos) = 0;


        virtual int GetOffMeshHitType() = 0;


        virtual void SetOffMeshHitType(int type) = 0;

        virtual float GetOffMeshHitZDepth() = 0;
        virtual void SetOffMeshHitZDepth(float depth) = 0;

        virtual Point3 GetOffMeshHitPos() = 0;
        virtual void SetOffMeshHitPos(Point3 pos) = 0;


    };

    class FaceDataFromPatch: public MaxHeapOperators
    {
    public:
        int owningPatch;  
        Point2 st[3];    
    };

    class IPainterRightClickHandler: public MaxHeapOperators
    {
    public:
        virtual void RightClick ()=0;
    };

    class IPainterInterface_V7 : public IPainterInterface_V5
    {
    public:

        virtual BOOL  InitializeNodesByObjState(int flags, Tab<INode*> &nodeList, Tab<ObjectState> &objList) = 0;//tested


        virtual BOOL  UpdateMeshesByObjState(BOOL updatePointGather, Tab<ObjectState> &objList) = 0;

        virtual void  GetPatchFaceData(PatchMesh &patch, Tab<FaceDataFromPatch> &faceData) = 0;


        virtual BOOL  StartPaintSession (IPainterRightClickHandler *rightClicker) = 0;
    // I have to add this one over again, otherwise it doesn't show up in the V7 interface:
        virtual BOOL  StartPaintSession() = 0;//tested

        virtual float GetStrDragLimitMin() = 0;
        virtual void SetStrDragLimitMin(float l) = 0;

        virtual float GetStrDragLimitMax() = 0;
        virtual void SetStrDragLimitMax(float l) = 0;


    };

    class IPainterInterface_V14 : public IPainterInterface_V7
    {
    public:
        virtual BOOL GetUseSplineConstraint() = 0;
        virtual void SetUseSplineConstraint(BOOL onoff) = 0;
        virtual BOOL SetSplineConstraintNode(INode* snode) = 0;
        virtual BOOL IsSplineConstraintNodeValid() = 0;
    };


class IPainterCanvasInterface_V5: public MaxHeapOperators 
    {
    public:
    
        virtual BOOL  StartStroke() = 0;



        virtual BOOL  PaintStroke(
                          BOOL hit,
                          IPoint2 mousePos, 
                          Point3 worldPoint, Point3 worldNormal,
                          Point3 localPoint, Point3 localNormal,
                          Point3 bary,  int index,
                          BOOL shift, BOOL ctrl, BOOL alt, 
                          float radius, float str,
                          float pressure, INode *node,
                          BOOL mirrorOn,
                          Point3 worldMirrorPoint, Point3 worldMirrorNormal,
                          Point3 localMirrorPoint, Point3 localMirrorNormal
                          ) = 0;

        virtual BOOL  EndStroke() = 0;


        virtual BOOL  EndStroke(int ct, BOOL *hit, IPoint2 *mousePos, 
                          Point3 *worldPoint, Point3 *worldNormal,
                          Point3 *localPoint, Point3 *localNormal,
                          Point3 *bary,  int *index,
                          BOOL *shift, BOOL *ctrl, BOOL *alt, 
                          float *radius, float *str,
                          float *pressure, INode **node,
                          BOOL mirrorOn,
                          Point3 *worldMirrorPoint, Point3 *worldMirrorNormal,
                          Point3 *localMirrorPoint, Point3 *localMirrorNormal   ) = 0;

        virtual BOOL  CancelStroke() = 0;   

        virtual BOOL  SystemEndPaintSession() = 0;

        virtual void PainterDisplay(TimeValue t, ViewExp *vpt, int flags) = 0;


    };


class IPainterCanvasInterface_V5_1: public MaxHeapOperators
    {
    public:


        virtual void CanvasStartPaint()=0;

        virtual void CanvasEndPaint()=0;
    

    };

class IPainterCanvasInterface_V7: public MaxHeapOperators
{
    public:

        virtual void OnPaintBrushChanged() = 0;
};