mod_command.h

Go to the documentation of this file.

#ifndef LWPP_MOD_COMMAND_H
#define LWPP_MOD_COMMAND_H

#include <lwpp/global.h>

#include <lwmodeler.h>
#include <lwcmdseq.h>

namespace lwpp
{

  class PointScanner
  {
  public:
    static EDError doScan (void*p, const EDPointInfo* info) 
    {
      PointScanner *host = static_cast<PointScanner *>(p);
      return host->Scan(info);
    }
    virtual EDError Scan(const EDPointInfo* info) {return EDERR_NONE;}
  };

  class FastPointScanner
  {
  public:
    static EDError doScan (void*p, LWPntID id) 
    {
      FastPointScanner *host = static_cast<FastPointScanner *>(p);
      return host->Scan(id);
    }
    virtual EDError Scan(LWPntID id) {return EDERR_NONE;}
  };

  class EdgeScanner
  {
  public:
    static EDError doScan (void*p, const EDEdgeInfo* info) 
    {
      EdgeScanner *host = static_cast<EdgeScanner *>(p);
      return host->Scan(info);
    }
    virtual EDError Scan(const EDEdgeInfo* info) {return EDERR_NONE;}
  };

  class FastEdgeScanner
  {
  public:
    static EDError doScan (void*p, LWEdgeID id) 
    {
      FastEdgeScanner *host = static_cast<FastEdgeScanner *>(p);
      return host->Scan(id);
    }
    virtual EDError Scan(LWEdgeID id) {return EDERR_NONE;}
  };

  class PolyScanner
  {
  public:
    static EDError doScan (void*p, const EDPolygonInfo* info) 
    {
      PolyScanner *host = static_cast<PolyScanner *>(p);
      return host->Scan(info);
    }
    virtual EDError Scan(const EDPolygonInfo* info) {return EDERR_NONE;}
  };

  class FastPolyScanner
  {
  public:
    static EDError doScan (void*p, LWPolID id) 
    {
      FastPolyScanner *host = static_cast<FastPolyScanner *>(p);
      return host->Scan(id);
    }
    virtual EDError Scan(LWPolID id) {return EDERR_NONE;}
  };

  class MeshEditOperator
  {
  protected:
    const MeshEditOp *me;
  public:
    MeshEditOperator(const MeshEditOp *_me = 0)
      : me(_me)
    {}

    MeshEditOperator(const MeshEditOp &_me)
      : me(&_me)
    {}

    void SetMeshEditOp(const MeshEditOp *_me)
    {
      me = _me;
    }

    MeshEditOperator& operator=(const MeshEditOperator &from)
    {
      if (this != &from)
      {
        me = from.me;
      }
    }
    int getLayer() {assert(me!=0); return me->layerNum;}

    void Done (EDError err, int selm)
    {
      assert(me!=0);
      if(me) me->done(me->state, err, selm);
    }

    int GetPointCount (EltOpLayer lyr, int mode)
    {
      assert(me!=0);
      if(me) return me->pointCount(me->state, lyr, mode);
      return 0;
    }

    int GetPolyCount (EltOpLayer lyr, int mode)
    {
      assert(me!=0);
      if(me) return me->polyCount(me->state, lyr, mode);
      return 0;
    }

    EDError Scan(PointScanner &scanner, EltOpLayer lyr)
    {
      assert(me!=0);
      if(me) return me->pointScan (me->state, &PointScanner::doScan, &scanner, lyr);
      return 0;
    }

    EDError Scan(FastPointScanner &scanner, EltOpLayer lyr, bool selOnly)
    {
      assert(me!=0);
      if(me) return me->fastPointScan (me->state, &FastPointScanner::doScan, &scanner, lyr, selOnly ? 1 : 0);
      return 0;
    }

    EDError Scan(PolyScanner &scanner, EltOpLayer lyr)
    {
      assert(me!=0);
      if(me) return me->polyScan (me->state, &PolyScanner::doScan, &scanner, lyr);
      return 0;
    }

    EDError Scan(FastPolyScanner &scanner, EltOpLayer lyr, bool selOnly)
    {
      assert(me!=0);
      if(me) return me->fastPolyScan (me->state, &FastPolyScanner::doScan, &scanner, lyr, selOnly ? 1 : 0);
      return 0;
    }

    EDPointInfo *GetInfo (LWPntID id)
    {
      assert(me!=0);
      if(me) return me->pointInfo (me->state, id);
      return 0;
    }

    EDPolygonInfo *GetInfo (LWPolID id)
    {
      assert(me!=0);
      if (me) return me->polyInfo (me->state, id);
      return 0;
    }

    bool GetPolyNormal(LWPolID id, double n[3])
    {
      assert(me!=0);
      if (me)
      {
        return (me->polyNormal(me->state, id, n) != 0);
      }
      return false;
    }

    LWPntID AddPoint(double *xyz)
    {
      assert(me!=0);
      if (me) return me->addPoint(me->state, xyz);
      return 0;
    }

    LWPolID AddFace(const char *surf, int numPnt, const LWPntID *pnts)
    {
      assert(me!=0);
      if (me) return me->addFace(me->state, surf, numPnt, pnts);
      return 0;
    }

    LWPolID AddCurve(const char *surf, int numPnt, const LWPntID *pnts, int flags)
    {
      assert(me!=0);
      if (me) return me->addCurve(me->state, surf, numPnt, pnts, flags);
      return 0;
    }

    EDError AddQuad(LWPntID p1, LWPntID p2, LWPntID p3, LWPntID p4)
    {
      assert(me!=0);
      if (me) return me->addQuad(me->state, p1, p2, p3, p4);
      return 0;
    }

    EDError AddTri(LWPntID p1, LWPntID p2, LWPntID p3)
    {
      assert(me!=0);
      if (me) return me->addTri(me->state, p1, p2, p3);
      return 0;
    }

    EDError AddPatch(int nr, int nc, int lr, int lc, EDBoundCv *r0, EDBoundCv *r1, EDBoundCv *c0, EDBoundCv *c1)
    {
      assert(me!=0);
      if (me) return me->addPatch(me->state, nr, nc, lr, lc, r0, r1, c0, c1);
      return 0;
    }

    EDError Remove (LWPntID id)
    {
      assert(me!=0);
      if (me) return me->remPoint (me->state, id);
      return 0;
    }

    EDError Remove (LWPolID id)
    {
      assert(me!=0);
      if (me) return me->remPoly (me->state, id);
      return 0;
    }

    EDError Move (LWPntID id, const double *delta)
    {
      assert(me!=0);
      if (me) return me->pntMove (me->state, id, delta);
      return 0;
    }

    EDError SetSurface (LWPolID id, const char *name)
    {
      assert(me!=0);
      if (me) return me->polSurf (me->state, id, name);
      return 0;
    }

    EDError ReplacePolyPoints (LWPolID id, int n, const LWPntID *p)
    {
      assert(me!=0);
      if (me) return me->polPnts (me->state, id, n, p);
      return 0;
    }


    EDError SetPolyFlags (LWPolID id, int mask, int value)
    {
      assert(me!=0);
      if (me) return me->polFlag (me->state, id, mask, value);
      return 0;
    }


    EDError SetPolTag (LWPolID id, LWID type, const char *name = 0)
    {
      assert(me!=0);
      if (me) return me->polTag (me->state, id, type, name);
      return 0;
    }


    EDError SetVMap (LWPntID id, LWID vmap, const char *c = 0, int i = 0, float *f = 0)
    {
      assert(me!=0);
      if (me) return me->pntVMap (me->state, id, vmap, c, i, f);
      return 0;
    }


    LWPolID AddPoly (LWID type, int numPnt, const LWPntID *pnt, LWPolID tmpl = 0, const char *surf = 0 )
    {
      assert(me!=0);
      if (me) return me->addPoly (me->state, type, tmpl, surf, numPnt, pnt);
      return 0;
    }


    LWPntID AddIPoint (double *xyz, int numPnt, const LWPntID *ids, const double *wt = 0)
    {
      assert(me!=0);
      if (me) return me->addIPnt (me->state, xyz, numPnt, ids, wt);
      return 0;
    }
    LWPntID AddIPoint (int numPnt, const LWPntID *ids, const double *wt = 0)
    {
      return AddIPoint(0, numPnt, ids, wt);
    }


    EDError InitUV (float *uv)
    {
      assert(me!=0);
      if (me) return me->initUV (me->state, uv);
      return 0;
    }


    void *Select (void *vmapID, LWID vmaptype, const char *vmapname)
    {
      assert(me!=0);
      if (me) return me->pointVSet (me->state, vmapID, vmaptype, vmapname);
      return 0;
    }
    void *Select (LWID vmaptype, const char *vmapname)
    {
      return Select(0, vmaptype, vmapname);
    }

    bool ReadVMap (LWPntID point, float *val)
    {
      assert(me!=0);
      if (me) return (me->pointVGet (me->state, point, val) != 0);
      return 0;
    }


    const char *GetPolyTag (LWPolID polygon, LWID tagtype)
    {
      assert(me!=0);
      if (me) return me->polyTag (me->state, polygon, tagtype);
      return "";
    }


    EDError Select (LWPntID pnt, bool sel)
    {
      assert(me!=0);
      if (me) return me->pntSelect (me->state, pnt, sel ? 1 : 0);
      return 0;
    }


    EDError Select (LWPolID pol, bool sel)
    {
      assert(me!=0);
      if (me) return me->polSelect (me->state, pol, sel ? 1 : 0);
      return 0;
    }


    bool ReadVMap (LWPntID point, LWPolID pol, float *val)
    {
      assert(me!=0);
      if (me) return (me->pointVPGet (me->state, point, pol, val) != 0);
      return 0;
    }


    bool EvaluateVMap (LWPntID point, LWPolID pol, float *val)
    {
      assert(me!=0);
      if (me) return (me->pointVEval (me->state, point, pol, val) != 0);
      return 0;
    }

    EDError AddDiscoVMap (LWPntID point, LWPolID pol, LWID type, const char *name, int dim, float *val)
    {
      assert(me!=0);
      if (me) return me->pntVPMap (me->state, point, pol, type, name, dim, val);
      return 0;
    }

    /*
    LWPntID             (*edgePoint1)       (EDStateRef, LWEdgeID);
    LWPntID             (*edgePoint2)       (EDStateRef, LWEdgeID);
    LWEdgeID            (*edgeFromPoints)   (EDStateRef, LWPntID, LWPntID);
    void                (*edgeFlip)         (EDStateRef, LWEdgeID);
    */
    int GetEdgeCount (EltOpLayer lyr, int mode)
    {
      assert(me!=0);
      if (me) return me->edgeCount (me->state, lyr, mode);
      return 0;
    }

    EDError Scan(EdgeScanner &scanner, EltOpLayer lyr)
    {
      assert(me!=0);
      if(me) return me->edgeScan (me->state, &EdgeScanner::doScan, &scanner, lyr);
      return 0;
    }

    EDError Scan(FastEdgeScanner &scanner, EltOpLayer lyr, bool selOnly)
    {
      assert(me!=0);
      if(me) return me->fastEdgeScan (me->state, &FastEdgeScanner::doScan, &scanner, lyr, selOnly ? 1 : 0);
      return 0;
    }

    EDEdgeInfo *GetInfo (LWEdgeID id)
    {
      assert(me!=0);
      if (me) return me->edgeInfo (me->state, id);
      return 0;
    }


    EDError Select (LWEdgeID edge, bool sel)
    {
      assert(me!=0);
      if (me) return me->edgeSelect (me->state, edge, sel ? 1 : 0);
      return 0;
    }

    int GetEdgePolys (LWEdgeID edge, const LWPolID**pols)
    {
      assert(me!=0);
      if (me) return me->edgePolys (me->state, edge, pols);
      return 0;
    }

    LWPntID GetEdgePoint1 (LWEdgeID edge)
    {
      assert(me!=0);
      if (me) return me->edgePoint1 (me->state, edge);
      return 0;
    }

    LWPntID GetEdgePoint2 (LWEdgeID edge)
    {
      assert(me!=0);
      if (me) return me->edgePoint2 (me->state, edge);
      return 0;
    }


    LWEdgeID GetEdge (LWPntID p1, LWPntID p2)
    {
      assert(me!=0);
      if (me) return me->edgeFromPoints (me->state, p1, p2);
      return 0;
    }

    void FlipEdge (LWEdgeID edge)
    {
      assert(me!=0);
      if (me) me->edgeFlip (me->state, edge);
    }

    void GetPointPosition (LWPntID pnt, double pos[3])
    {
      assert(me!=0);
      if (me) me->pointPos (me->state, pnt, pos);
    }

    int GetPointEdges (LWPntID pnt, const LWEdgeID **edges)
    {
      assert(me!=0);
      if (me) return me->pointEdges (me->state, pnt, edges);
      return 0;
    }

    unsigned int GetPolyType (LWPolID pol)
    {
      assert(me!=0);
      if (me) return me->polyType (me->state, pol);
      return 0;
    }

    int GetPolyPoints (LWPolID pol, const LWPntID **pnts)
    {
      assert(me!=0);
      if (me) return me->polyPoints (me->state, pol, pnts);
      return 0;
    }

    int GetFlags (LWPntID pnt)
    {
      assert(me!=0);
      if (me) return me->pointFlags (me->state, pnt);
      return 0;
    }

    int GetFlags (LWEdgeID edg)
    {
      assert(me!=0);
      if (me) return me->edgeFlags (me->state, edg);
      return 0;
    }

    int GetFlags (LWPolID pol)
    {
      assert(me!=0);
      if (me) return me->polyFlags (me->state, pol);
      return 0;
    }

    void *GetData (LWPntID pnt)
    {
      assert(me!=0);
      if (me) return me->pointData (me->state, pnt);
      return 0;
    }

    void *GetData (LWEdgeID edg)
    {
      assert(me!=0);
      if (me) return me->edgeData (me->state, edg);
      return 0;
    }

    void *GetData (LWPolID pol)
    {
      assert(me!=0);
      if (me) return me->polyData (me->state, pol);
      return 0;
    }

    int GetLayer (LWPntID pnt)
    {
      assert(me!=0);
      if (me) return me->pointLayer (me->state, pnt);
      return 0;
    }

    int GetLayer (LWEdgeID edg)
    {
      assert(me!=0);
      if (me) return me->edgeLayer (me->state, edg);
      return 0;
    }

    int GetLayer (LWPolID pol)
    {
      assert(me!=0);
      if (me) return me->polyLayer (me->state, pol);
      return 0;
    }

    int SetLayer (int lyr)
    {
      assert(me!=0);
      if (me) return me->setLayer (me->state, lyr);
      return 0;
    }
    int AdvanceLayer ()
    {
      assert(me!=0);
      if (me) return me->advanceLayer (me->state);
      return 0;
    }

    int PointNew (LWPntID pnt)
    {
      assert(me!=0);
      if (me) return me->pointNew (me->state, pnt);
      return 0;
    }

    int EdgeNew (LWEdgeID edg)
    {
      assert(me!=0);
      if (me) return me->edgeNew (me->state, edg);
      return 0;
    }

    int PolyNew (LWPolID pol)
    {
      assert(me!=0);
      if (me) return me->polyNew (me->state, pol);
      return 0;
    }

    /*
    // new in Lightwave 9.6 - LWMESHEDIT_VERSION 6
    void *               (*vMapSelect)      (EDStateRef es, const char* name, LWID type, int dim);
    int                  (*vMapExists)      (EDStateRef es, const char* name, LWID type);
    unsigned int         (*vMapGetDimension)(EDStateRef es);
    void                 (*vMapSet)         (EDStateRef es, LWPntID point_id, LWPolID polygon_id, const float *value);
    void                 (*vMapSetIdeal)    (EDStateRef es, LWPntID point_id, LWPolID polygon_id, const float *value);
    void                 (*vMapRename)      (EDStateRef es, const char *new_name);
    void                 (*vMapRemove)      (EDStateRef es);
    */

  };


  class ModelerCommand : public MeshEditOperator
  {
    LWModCommand *mc;

    MeshEditBegin*        editBegin()
    {
      assert(mc!=0);
      return mc->editBegin;
    }
    MeshEditBegin2*       editBegin2()
    {
      assert(mc!=0);
      return mc->editBegin2;
    }

  protected:
    int version;
    const char *GetArgument()
    {
      assert(mc!=0);
      return mc->argument;
    }
    LWCommandCode Lookup (const char *cmdName)
    {
      assert(mc!=0);
      return mc->lookup(mc->data, cmdName);
    }
    int  Execute        (LWCommandCode cmd, int argc, const DynaValue *argv, EltOpSelect op, DynaValue *result)
    {
      assert(mc!=0);
      return mc->execute(mc->data, cmd, argc, argv, op, result);
    }
    int  Evaluate         (const char *command)
    {
      assert(mc!=0);
      return mc->evaluate(mc->data, command);
    }
    void BeginUndoGroup() 
    {
      assert(mc!=0);
      mc->undoGroupBegin();
    }
    void EndUndoGroup()
    {
      assert(mc!=0);
      mc->undoGroupEnd();
    }

    void EditBegin (int pntBuf, int polBuf, EltOpSelect opsel)
    {
      assert(mc!=0);
      SetMeshEditOp(mc->editBegin(pntBuf, polBuf, opsel));
    }

    void EditBegin (int pntBuf, int edgeBuf, int polBuf, EltOpSelect opsel)
    {
      assert(mc!=0);
      return SetMeshEditOp(mc->editBegin2(pntBuf, edgeBuf, polBuf, opsel));
    }
  public: 
    ModelerCommand(int _version, LWModCommand *_mc)
      : mc(_mc), version(_version)
    {
    }

    virtual int Activate (void* p) = 0;

  };

  template <typename T>
  class ModelerCommandAdaptor
  {
  public:
    ModelerCommandAdaptor(const char *name, ServerTagInfo *tags = 0)
    {
      LWServer::AddPlugin(LWMODCOMMAND_CLASS, name, Activate, tags);
    }
    static int Activate ( int version, GlobalFunc* global, LWInstance inst, void* serverData)
    {
      LWModCommand *local = static_cast<LWModCommand *>(inst);
      lwpp::SetSuperGlobal(global);
      T plugin(version, local);
      return plugin.Activate(serverData);
    }
  };

} // end namespace lwpp

#endif // LWPP_MOD_COMMAND_H