scolplugin.cpp

/*
-----------------------------------------------------------------------------
This source file is part of OpenSpace3D
For the latest info, see http://www.openspace3d.com

Copyright (c) 2013 I-maginer

This program is free software; you can redistribute it and/or modify it under
the terms of the GNU Lesser General Public License as published by the Free Software
Foundation; either version 2 of the License, or (at your option) any later
version.

This program is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with
this program; if not, write to the Free Software Foundation, Inc., 59 Temple
Place - Suite 330, Boston, MA 02111-1307, USA, or go to
http://www.gnu.org/copyleft/lesser.txt

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

/*
 TUIO interface for Scol
 First version : MAY 2013
 Author : Bastien BOURINEAU
*/

#include "sTuio.h"
#include <scolPlugin.h>
#include <scolMemoryHelper.hpp>

#ifdef SCOL_STATIC
extern cbmachine        ww;
extern mmachine mm;
#else
cbmachine       ww;
mmachine mm;
#endif

int OBJTUIOSCOL;
int TUIO_CURSOR_ADD_CB;
int SCOL_TUIO_CURSOR_ADD_CB = 0;
int TUIO_CURSOR_REMOVE_CB;
int SCOL_TUIO_CURSOR_REMOVE_CB = 1;
int TUIO_CURSOR_UPDATE_CB;
int SCOL_TUIO_CURSOR_UPDATE_CB = 2;

int TUIO_OBJECT_ADD_CB;
int SCOL_TUIO_OBJECT_ADD_CB = 3;
int TUIO_OBJECT_REMOVE_CB;
int SCOL_TUIO_OBJECT_REMOVE_CB = 4;
int TUIO_OBJECT_UPDATE_CB;
int SCOL_TUIO_OBJECT_UPDATE_CB = 5;


int destroyTuioObj(mmachine m, SCOL_PTR_TYPE handsys, int handscol) {
        // Read the first element of a TAB element (table of object)
  STuioClient* tuioobj = MMgetPointer<STuioClient*>(m, MTOP(handscol));
  SAFE_DELETE(tuioobj);

  MMsetPointer(m, MTOP(handscol), NULL);

        // Display debug message
        MMechostr(MSKDEBUG, "ObjTUIO destroyed.\n");
        return 0;
}


int _CRTuioClient(mmachine m)
{
#ifdef _SCOL_DEBUG_
        MMechostr(0,"_CRTuioClient\n");
#endif
        // Declare local variables
        int k = 0;

  int sPort = MMpull(m);

        // Get the channel without pulling it (first element in the stack)
  int channel = MMget(m, 0);

        // Test the channel
  if (channel == NIL)
  { 
                MMechostr(MSKDEBUG, "Channel NIL\n");
    MMset(m, 0, NIL);
                return 0;
        }
  
  int port = 3333;
  if (sPort != NIL)
    port = MTOI(sPort);

  STuioClient* tuioObj = new STuioClient(port);
        if (tuioObj == NULL)
  {
                MMechostr(MSKDEBUG, "tuioObj failed\n");
                SAFE_DELETE(tuioObj); 
    MMset(m, 0, NIL);
    return 0;
        }
  
        // Allocate a space in the stack for a table of object
  if ((MMpushPointer(m, tuioObj) != 0))
  {
    SAFE_DELETE(tuioObj);
    MMset(m, 0, NIL);
    return MERRMEM;
  }

        // Create a new scol joypad object
        k = OBJcreate(m, OBJTUIOSCOL, SCOL_PTR tuioObj, NULL, NULL);

#ifdef  _SCOL_DEBUG_
        MMechostr(0,"ok\n");
#endif

        return k;
}

int _DSTuioClient(mmachine m)
{
#ifdef  _SCOL_DEBUG_
        MMechostr(MSKDEBUG,"_DSTuioClient\n");
#endif
        
        int objTab = MMget(m, 0);
        if (objTab == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
        
        OBJdelTM(m, OBJTUIOSCOL, objTab);
        MMset(m, 0, ITOM(0));

#ifdef  _SCOL_DEBUG_
        MMechostr(MSKDEBUG,"ok\n");
#endif
        return 0;
}

int _CONNECTTuioClient(mmachine m)
{
#ifdef  _SCOL_DEBUG_
        MMechostr(MSKDEBUG, "_CONNECTTuioClient\n");
#endif

  int objTab = MMget(m, 0);
        if (objTab == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }

  STuioClient* tuioObj = MMgetPointer<STuioClient*>(m, MTOP(objTab));
  if (tuioObj == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }

  if (tuioObj->Connect())
    MMset(m, 0, ITOM(1));
  else
    MMset(m, 0, ITOM(0));

#ifdef  _SCOL_DEBUG_
        MMechostr(MSKDEBUG, "ok\n");
#endif
        return 0;
}

int _DISCONNECTTuioClient(mmachine m)
{
#ifdef  _SCOL_DEBUG_
        MMechostr(MSKDEBUG, "_DISCONNECTTuioClient\n");
#endif

  int objTab = MMget(m, 0);
        if (objTab == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }

  STuioClient* tuioObj = MMgetPointer<STuioClient*>(m, MTOP(objTab));
  if (tuioObj == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }

  tuioObj->Disconnect();
  MMset(m, 0, ITOM(1));

#ifdef  _SCOL_DEBUG_
        MMechostr(MSKDEBUG, "ok\n");
#endif
        return 0;
}


int _CBTuioAddCursor(mmachine m)
{
        return OBJaddreflex (m, OBJTUIOSCOL, SCOL_TUIO_CURSOR_ADD_CB);
}


int getTUIOCursorAddCb(mmachine m, SCOL_PTR_TYPE wParam, LONG lParam)
{
  SCbData* tuioData = (SCbData*)lParam;

  //call the scol callback
  if (OBJbeginreflex(m, OBJTUIOSCOL, SCOL_PTR wParam, SCOL_TUIO_CURSOR_ADD_CB))
  {
                MMechostr(MSKDEBUG, "ObjTUIO callback not found\n");
                return 0;
  }

  // push params
  MMpush(m, ITOM(tuioData->id));
  MMpush(m, FTOM(tuioData->x));
  MMpush(m, FTOM(tuioData->y));
  MMpush(m, FTOM(tuioData->xvel));
  MMpush(m, FTOM(tuioData->yvel));

  // Call reflex previously defined
        int k = OBJcallreflex(m, 5 /*nb param after obj and u0*/);

  // free data
  delete(tuioData);
  return k;
}


int _CBTuioUpdateCursor(mmachine m)
{
        return OBJaddreflex (m, OBJTUIOSCOL, SCOL_TUIO_CURSOR_UPDATE_CB);
}


int getTUIOCursorUpdateCb(mmachine m, SCOL_PTR_TYPE wParam, LONG lParam)
{
  SCbData* tuioData = (SCbData*)lParam;

  //call the scol callback
  if (OBJbeginreflex(m, OBJTUIOSCOL, SCOL_PTR wParam, SCOL_TUIO_CURSOR_UPDATE_CB))
  {
                MMechostr(MSKDEBUG, "ObjTUIO callback not found\n");
                return 0;
  }

  // push params
  MMpush(m, ITOM(tuioData->id));
  MMpush(m, FTOM(tuioData->x));
  MMpush(m, FTOM(tuioData->y));
  MMpush(m, FTOM(tuioData->xvel));
  MMpush(m, FTOM(tuioData->yvel));

  // Call reflex previously defined
        int k = OBJcallreflex(m, 5 /*nb param after obj and u0*/);

  // free data
  delete(tuioData);
  return k;
}

int _CBTuioRemoveCursor(mmachine m)
{
        return OBJaddreflex (m, OBJTUIOSCOL, SCOL_TUIO_CURSOR_REMOVE_CB);
}


int getTUIOCursorRemoveCb(mmachine m, SCOL_PTR_TYPE wParam, LONG lParam)
{
  int id = (int)lParam;

  //call the scol callback
  if (OBJbeginreflex(m, OBJTUIOSCOL, SCOL_PTR wParam, SCOL_TUIO_CURSOR_REMOVE_CB))
  {
                MMechostr(MSKDEBUG, "ObjTUIO callback not found\n");
                return 0;
  }

  // push the id
  MMpush(m, ITOM(id));

  // Call reflex previously defined
        int k = OBJcallreflex(m, 1 /*nb param after obj and u0*/);

  return k;
}

int _CBTuioAddObject(mmachine m)
{
        return OBJaddreflex (m, OBJTUIOSCOL, SCOL_TUIO_OBJECT_ADD_CB);
}


int getTUIOObjectAddCb(mmachine m, SCOL_PTR_TYPE wParam, LONG lParam)
{
  SCbData* tuioData = (SCbData*)lParam;

  //call the scol callback
  if (OBJbeginreflex(m, OBJTUIOSCOL, SCOL_PTR wParam, SCOL_TUIO_OBJECT_ADD_CB))
  {
                MMechostr(MSKDEBUG, "ObjTUIO callback not found\n");
                return 0;
  }

  // push params
  MMpush(m, ITOM(tuioData->id));
  MMpush(m, FTOM(tuioData->x));
  MMpush(m, FTOM(tuioData->y));
  MMpush(m, FTOM(tuioData->ang));
  MMpush(m, FTOM(tuioData->xvel));
  MMpush(m, FTOM(tuioData->yvel));
  MMpush(m, FTOM(tuioData->angvel));

  // Call reflex previously defined
        int k = OBJcallreflex(m, 7 /*nb param after obj and u0*/);

  // free data
  delete(tuioData);
  return k;
}


int _CBTuioUpdateObject(mmachine m)
{
        return OBJaddreflex(m, OBJTUIOSCOL, SCOL_TUIO_OBJECT_UPDATE_CB);
}


int getTUIOObjectUpdateCb(mmachine m, SCOL_PTR_TYPE wParam, LONG lParam)
{
  SCbData* tuioData = (SCbData*)lParam;

  //call the scol callback
  if (OBJbeginreflex(m, OBJTUIOSCOL, SCOL_PTR wParam, SCOL_TUIO_OBJECT_UPDATE_CB))
  {
                MMechostr(MSKDEBUG, "ObjTUIO callback not found\n");
                return 0;
  }

  // push params
  MMpush(m, ITOM(tuioData->id));
  MMpush(m, FTOM(tuioData->x));
  MMpush(m, FTOM(tuioData->y));
  MMpush(m, FTOM(tuioData->ang));
  MMpush(m, FTOM(tuioData->xvel));
  MMpush(m, FTOM(tuioData->yvel));
  MMpush(m, FTOM(tuioData->angvel));

  // Call reflex previously defined
        int k = OBJcallreflex(m, 7 /*nb param after obj and u0*/);

  // free data
  delete(tuioData);
  return k;
}

int _CBTuioRemoveObject(mmachine m)
{
        return OBJaddreflex(m, OBJTUIOSCOL, SCOL_TUIO_OBJECT_REMOVE_CB);
}


int getTUIOObjectRemoveCb(mmachine m, SCOL_PTR_TYPE wParam, LONG lParam)
{
  int id = (int)lParam;

  //call the scol callback
  if (OBJbeginreflex(m, OBJTUIOSCOL, SCOL_PTR wParam, SCOL_TUIO_OBJECT_REMOVE_CB))
  {
                MMechostr(MSKDEBUG, "ObjTUIO callback not found\n");
                return 0;
  }

  // push the id
  MMpush(m, ITOM(id));

  // Call reflex previously defined
        int k = OBJcallreflex(m, 1 /*nb param after obj and u0*/);

  return k;
}

char* mTUIOname[]=
{
  "ObjTUIO",

  "_CRTuioClient",
  "_DSTuioClient",
  "_CONNECTTuioClient",
  "_DISCONNECTTuioClient",
  "_CBTuioAddCursor",
  "_CBTuioUpdateCursor",
  "_CBTuioRemoveCursor",
  "_CBTuioAddObject",
  "_CBTuioUpdateObject",
  "_CBTuioRemoveObject"
};

#define NTUIOPKG (sizeof(mTUIOname)/sizeof(char*))

int (*mTUIOfun[NTUIOPKG])(mmachine m)=
{
  NULL,             //ObjTUIO

  _CRTuioClient,
  _DSTuioClient,
  _CONNECTTuioClient,
  _DISCONNECTTuioClient,
  _CBTuioAddCursor,
  _CBTuioUpdateCursor,
  _CBTuioRemoveCursor,
  _CBTuioAddObject,
  _CBTuioUpdateObject,
  _CBTuioRemoveObject

};

int mTUIOnarg[NTUIOPKG]=
{
  TYPTYPE,          //ObjTUIO

  2,                //_CRTuioClient
  1,                //_DSTuioClient
  1,                //_CONNECTTuioClient
  1,                //_DISCONNECTTuioClient
  3,                //_CBTuioAddCursor
  3,                //_CBTuioUpdateCursor
  3,                //_CBTuioRemoveCursor
  3,                //_CBTuioAddObject
  3,                //_CBTuioUpdateObject
  3                 //_CBTuioRemoveObject
};

char* mTUIOtype[NTUIOPKG]=
{
  NULL,                                                         //ObjTUIO

  "fun [Chn I] ObjTUIO",                                        //_CRTuioClient
  "fun [ObjTUIO] I",                                            //_DSTuioClient
  "fun [ObjTUIO] I",                                            //_CONNECTTuioClient
  "fun [ObjTUIO] I",                                            //_DISCONNECTTuioClient
  "fun [ObjTUIO fun [ObjTUIO u0 I F F F F] u1 u0] ObjTUIO",     //_CBTuioAddCursor
  "fun [ObjTUIO fun [ObjTUIO u0 I F F F F] u1 u0] ObjTUIO",     //_CBTuioUpdateCursor
  "fun [ObjTUIO fun [ObjTUIO u0 I] u1 u0] ObjTUIO",             //_CBTuioRemoveCursor
  "fun [ObjTUIO fun [ObjTUIO u0 I F F F F F F] u1 u0] ObjTUIO", //_CBTuioAddObject
  "fun [ObjTUIO fun [ObjTUIO u0 I F F F F F F] u1 u0] ObjTUIO", //_CBTuioUpdateObject
  "fun [ObjTUIO fun [ObjTUIO u0 I] u1 u0] ObjTUIO"              //_CBTuioRemoveObject
};


// Everything inside _cond and _endcond is ignored by doxygen

int LoadTUIO(mmachine m)
{
        int k = 0;

        MMechostr(MSKDEBUG,"\n" );
  MMechostr(MSKDEBUG," > Loading TUIO Support\n");

  // Declare a new type of object ("ObjTUIO")
        OBJTUIOSCOL = OBJregister(6 /*nb of callback*/, 0, destroyTuioObj, "OBJTUIOSCOL");
        k = PKhardpak(m, "mTUIO.pkg-1.0", NTUIOPKG, mTUIOname, mTUIOfun, mTUIOnarg, mTUIOtype);
        
  // Register data callback
  TUIO_CURSOR_ADD_CB = OBJgetUserEvent();
        OBJdefEvent(TUIO_CURSOR_ADD_CB, getTUIOCursorAddCb);
  
  TUIO_CURSOR_REMOVE_CB = OBJgetUserEvent();
        OBJdefEvent(TUIO_CURSOR_REMOVE_CB, getTUIOCursorRemoveCb);

  TUIO_CURSOR_UPDATE_CB = OBJgetUserEvent();
        OBJdefEvent(TUIO_CURSOR_UPDATE_CB, getTUIOCursorUpdateCb);

  TUIO_OBJECT_ADD_CB = OBJgetUserEvent();
        OBJdefEvent(TUIO_OBJECT_ADD_CB, getTUIOObjectAddCb);
  
  TUIO_OBJECT_REMOVE_CB = OBJgetUserEvent();
        OBJdefEvent(TUIO_OBJECT_REMOVE_CB, getTUIOObjectRemoveCb);

  TUIO_OBJECT_UPDATE_CB = OBJgetUserEvent();
        OBJdefEvent(TUIO_OBJECT_UPDATE_CB, getTUIOObjectUpdateCb);

  MMechostr(MSKDEBUG," > Successfully Loaded\n\n");
        return k;
}

int CloseTUIO()
{
  MMechostr(MSKDEBUG,"\n" );
  MMechostr(MSKDEBUG," > Unloading TUIO Support\n");  
  MMechostr(MSKDEBUG," > Successfully unloaded\n\n");
  return 0;
}



#ifndef SCOL_STATIC
extern "C" SCOL_EXPORT int ScolLoadPlugin(mmachine m, cbmachine w)
#else
extern "C" SCOL_EXPORT int ScolStuioLoadPlugin(mmachine m, cbmachine w)
#endif
{
  SCOLinitplugin(w);
  return LoadTUIO(m);
}

#ifndef SCOL_STATIC
extern "C" SCOL_EXPORT int ScolUnloadPlugin()
#else
extern "C" SCOL_EXPORT int ScolStuioUnloadPlugin()
#endif
{
  return CloseTUIO();
}