scolplugin.cpp

/*
-----------------------------------------------------------------------------
This source file is part of OpenSpace3D
For the latest info, see http://www.openspace3d.com
 
Copyright (c) 2012 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
 
-----------------------------------------------------------------------------
*/
 
/*
 VRPN interface for Scol
 First version : July 2013
 Author : Bastien BOURINEAU - I-Maginer
*/
 
#include "sVrpn.h"
#include <scolMemoryHelper.hpp>
 
#ifdef SCOL_STATIC
extern cbmachine        ww;
extern mmachine mm;
#else
cbmachine       ww;
mmachine mm;
#endif
 
int OBJ_VRPN_SCOL;
 
int VRPN_ANALOG_CB;
int SCOL_VRPN_ANALOG_CB = 0;
 
int VRPN_BTN_CB;
int SCOL_VRPN_BTN_CB = 1;
int VRPN_BTN_STATE_CB;
int SCOL_VRPN_BTN_STATE_CB = 2;
 
int VRPN_TRACKER_CB;
int SCOL_VRPN_TRACKER_CB = 3;
int VRPN_TRACKER_VEL_CB;
int SCOL_VRPN_TRACKER_VEL_CB = 4;
int VRPN_TRACKER_ACC_CB;
int SCOL_VRPN_TRACKER_ACC_CB = 5;
 
int VRPN_DIAL_CB;
int SCOL_VRPN_DIAL_CB = 6;
 
int VRPN_TEXT_CB;
int SCOL_VRPN_TEXT_CB = 7;
 
int destroyVRPNObj(mmachine m, SCOL_PTR_TYPE handsys, int handscol) 
{
        // Read the first element of a TAB element (table of object)
  SVrpn* vrpnObj = MMgetPointer<SVrpn*>(m, MTOP(handscol));
  
        // Safely dispose of "vrpnObj" pointer
  sVrpnThread::GetInstance()->RemoveDevice(vrpnObj);
 
  MMsetPointer<SVrpn*>(m, MTOP(handscol), 0);
 
        // Display debug message
        MMechostr(MSKDEBUG, "ObjVRPN destroyed.\n");
        return 0;
}
 
 
int _CRvrpnDevice(mmachine m)
{
#ifdef _SCOL_DEBUG_
        MMechostr(0,"_CRvrpnDevice\n");
#endif
        // Declare local variables
        int k = 0;
 
  int sDevice = MMpull(m);
  int sHost = MMpull(m);
 
        // Get the channel without pulling it (first element in the stack)
  int channel = MMget(m, 0);
 
        // Test the channel
  if (channel == NIL || sDevice == NIL)
  { 
                MMechostr(MSKDEBUG, "Channel NIL\n");
    MMset(m, 0, NIL);
                return 0;
        }
 
  std::string hostName = "localhost";
 
  if (sHost != NIL)
    hostName = MMstartstr(m, MTOP(sHost));
  
  std::string deviceName = MMstartstr(m, MTOP(sDevice));
  SVrpn* vrpnObj = sVrpnThread::GetInstance()->AddDevice(hostName, deviceName);
        if (vrpnObj == NULL)
  {
                MMechostr(MSKDEBUG,"vrpnObj failed\n");
    MMset(m, 0, NIL);
    return 0;
        }
  
        // Allocate a space in the stack for a table of joypad object
  if ((MMpushPointer(m, vrpnObj) != 0))
  {
    sVrpnThread::GetInstance()->RemoveDevice(vrpnObj);
    MMset(m, 0, NIL);
    return MERRMEM;
  }
 
        // Create a new scol joypad object
        k = OBJcreate(m, OBJ_VRPN_SCOL, SCOL_PTR vrpnObj, NIL, 0);
 
#ifdef  _SCOL_DEBUG_
        MMechostr(0,"ok\n");
#endif
 
        return k;
}
 
int _DSvrpnDevice(mmachine m)
{
#ifdef  _SCOL_DEBUG_
        MMechostr(MSKDEBUG,"_DSvrpnDevice\n");
#endif
        
        int vrpnTab = MMget(m,0);
        if (vrpnTab == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
        
        OBJdelTM(m, OBJ_VRPN_SCOL, vrpnTab);
        MMset(m, 0, ITOM(0));
 
#ifdef  _SCOL_DEBUG_
        MMechostr(MSKDEBUG,"ok\n");
#endif
        return 0;
}
 
 
int _CBvrpnAnalogData(mmachine m)
{
  int vrpnTab = MMget(m, 2);
  int cb = MMget(m, 1);
 
  if (vrpnTab != NIL)
  {
    SVrpn* vrpnObj = MMgetPointer<SVrpn*>(m, MTOP(vrpnTab));
    vrpnObj->EnableAnalogData(cb == NIL ? false : true);
  }
 
        // Add a reflex
        MMechostr(MSKDEBUG, "_CBvrpnAnalogData ...adding reflex\n");
        return OBJaddreflex(m, OBJ_VRPN_SCOL, SCOL_VRPN_ANALOG_CB);
}
 
int getVRPNAnalogCb(mmachine m, SCOL_PTR_TYPE wParam, SCOL_PTR_TYPE lParam)
{
  SVrpn* vrpnObj = (SVrpn*) wParam;
  SCbData* vrpnData = (SCbData*) lParam;
 
  //call the scol callback
  if (OBJbeginreflex(m, OBJ_VRPN_SCOL, SCOL_PTR vrpnObj, SCOL_VRPN_ANALOG_CB))
  {
                MMechostr(MSKDEBUG, "ObjVRPN callback not found\n");
    delete(vrpnData);
                return 0;
  }
 
  for (unsigned int i = 0; i < vrpnData->analogData.size(); i++)
  {
          if (MMpush(m, FTOM(vrpnData->analogData[i])))         
      return MERRMEM;
  }
 
  if(MMpush(m, NIL))
    return MERRMEM;
 
  for(unsigned int j = 0; j < vrpnData->analogData.size(); j++)
  {
          if (MMpush(m, 2*2))
      return MERRMEM;
 
    if (int k=MBdeftab(m))
      return k;
  }
 
  // Call reflex previously defined
        int k = OBJcallreflex(m, 1 /*nb param after obj and u0*/);
 
  // free data
  delete(vrpnData);
  return k;
}
 
 
int _CBvrpnButtonData(mmachine m)
{
  int vrpnTab = MMget(m, 2);
  int cb = MMget(m, 1);
 
  if (vrpnTab != NIL)
  {
    SVrpn* vrpnObj = MMgetPointer<SVrpn*>(m, MTOP(vrpnTab));
    vrpnObj->EnableButtonData(cb == NIL ? false : true);
  }
 
        // Add a reflex
        MMechostr(MSKDEBUG, "_CBvrpnButtonData ...adding reflex\n");
        return OBJaddreflex(m, OBJ_VRPN_SCOL, SCOL_VRPN_BTN_CB);
}
 
int getVRPNBtnCb(mmachine m, SCOL_PTR_TYPE wParam, SCOL_PTR_TYPE lParam)
{
  SVrpn* vrpnObj = (SVrpn*) wParam;
  SCbData* vrpnData = (SCbData*) lParam;
 
  //call the scol callback
  if (OBJbeginreflex(m, OBJ_VRPN_SCOL, SCOL_PTR vrpnObj, SCOL_VRPN_BTN_CB))
  {
                MMechostr(MSKDEBUG, "ObjVRPN callback not found\n");
    delete(vrpnData);
                return 0;
  }
 
  for (unsigned int i = 0; i < vrpnData->btnData.size(); i++)
  {
          if (MMpush(m, ITOM(vrpnData->btnData[i])))            
      return MERRMEM;
  }
 
  if(MMpush(m, NIL))
    return MERRMEM;
 
  for(unsigned int j = 0; j < vrpnData->btnData.size(); j++)
  {
          if (MMpush(m, 2*2))
      return MERRMEM;
 
    if (int k=MBdeftab(m))
      return k;
  }
 
  // Call reflex previously defined
        int k = OBJcallreflex(m, 1 /*nb param after obj and u0*/);
 
  // free data
  delete(vrpnData);
  return k;
}
 
 
int _CBvrpnButtonState(mmachine m)
{
  int vrpnTab = MMget(m, 2);
  int cb = MMget(m, 1);
 
  if (vrpnTab != NIL)
  {
    SVrpn* vrpnObj = MMgetPointer<SVrpn*>(m, MTOP(vrpnTab));
    vrpnObj->EnableButtonStateData(cb == NIL ? false : true);
  }
 
        // Add a reflex
        MMechostr(MSKDEBUG, "_CBvrpnButtonState ...adding reflex\n");
        return OBJaddreflex(m, OBJ_VRPN_SCOL, SCOL_VRPN_BTN_STATE_CB);
}
 
int getVRPNBtnStateCb(mmachine m, SCOL_PTR_TYPE wParam, SCOL_PTR_TYPE lParam)
{
  SVrpn* vrpnObj = (SVrpn*) wParam;
  SCbData* vrpnData = (SCbData*) lParam;
 
  //call the scol callback
  if (OBJbeginreflex(m, OBJ_VRPN_SCOL, SCOL_PTR vrpnObj, SCOL_VRPN_BTN_STATE_CB))
  {
                MMechostr(MSKDEBUG, "ObjVRPN callback not found\n");
    delete(vrpnData);
                return 0;
  }
 
  MMpush(m, ITOM(vrpnData->valueId));
  MMpush(m, ITOM(vrpnData->btnState));
 
  // Call reflex previously defined
        int k = OBJcallreflex(m, 2 /*nb param after obj and u0*/);
 
  // free data
  delete(vrpnData);
  return k;
}
 
 
int _CBvrpnTrackerData(mmachine m)
{
  int vrpnTab = MMget(m, 2);
  int cb = MMget(m, 1);
 
  if (vrpnTab != NIL)
  {
    SVrpn* vrpnObj = MMgetPointer<SVrpn*>(m, MTOP(vrpnTab));
    vrpnObj->EnableTrackerData(cb == NIL ? false : true);
  }
 
        // Add a reflex
        MMechostr(MSKDEBUG, "_CBvrpnTrackerData ...adding reflex\n");
        return OBJaddreflex(m, OBJ_VRPN_SCOL, SCOL_VRPN_TRACKER_CB);
}
 
int getVRPNTrackerCb(mmachine m, SCOL_PTR_TYPE wParam, SCOL_PTR_TYPE lParam)
{
  SVrpn* vrpnObj = (SVrpn*) wParam;
  SCbData* vrpnData = (SCbData*) lParam;
 
  //call the scol callback
  if (OBJbeginreflex(m, OBJ_VRPN_SCOL, SCOL_PTR vrpnObj, SCOL_VRPN_TRACKER_CB))
  {
                MMechostr(MSKDEBUG, "ObjVRPN callback not found\n");
    delete(vrpnData);
                return 0;
  }
 
  MMpush(m, ITOM(vrpnData->valueId));
 
  int vec = MMmalloc(m, 3, TYPETAB);
        if(vec == NIL)
    return MERRMEM;             
 
  MMstore(m, vec, 0, FTOM(vrpnData->vectorData[0]));
  MMstore(m, vec, 1, FTOM(vrpnData->vectorData[1]));
        MMstore(m, vec, 2, FTOM(vrpnData->vectorData[2]));
  MMpush(m, PTOM(vec));
 
  int quat = MMmalloc(m, 4, TYPETAB);
        if(quat == NIL)
    return MERRMEM;             
 
  MMstore(m, quat, 0, FTOM(vrpnData->quatData[0]));
  MMstore(m, quat, 1, FTOM(vrpnData->quatData[1]));
        MMstore(m, quat, 2, FTOM(vrpnData->quatData[2]));
  MMstore(m, quat, 3, FTOM(vrpnData->quatData[3]));
  MMpush(m, PTOM(quat));
 
  // Call reflex previously defined
        int k = OBJcallreflex(m, 3 /*nb param after obj and u0*/);
 
  // free data
  delete(vrpnData);
  return k;
}
 
int _CBvrpnTrackerVelocityData(mmachine m)
{
  int vrpnTab = MMget(m, 2);
  int cb = MMget(m, 1);
 
  if (vrpnTab != NIL)
  {
    SVrpn* vrpnObj = MMgetPointer<SVrpn*>(m, MTOP(vrpnTab));
    vrpnObj->EnableTrackerVelData(cb == NIL ? false : true);
  }
 
        // Add a reflex
        MMechostr(MSKDEBUG, "_CBvrpnTrackerVelocityData ...adding reflex\n");
        return OBJaddreflex(m, OBJ_VRPN_SCOL, SCOL_VRPN_TRACKER_VEL_CB);
}
 
int getVRPNTrackerVelocityCb(mmachine m, SCOL_PTR_TYPE wParam, SCOL_PTR_TYPE lParam)
{
  SVrpn* vrpnObj = (SVrpn*) wParam;
  SCbData* vrpnData = (SCbData*) lParam;
 
  //call the scol callback
  if (OBJbeginreflex(m, OBJ_VRPN_SCOL, SCOL_PTR vrpnObj, SCOL_VRPN_TRACKER_VEL_CB))
  {
                MMechostr(MSKDEBUG, "ObjVRPN callback not found\n");
    delete(vrpnData);
                return 0;
  }
  
  MMpush(m, ITOM(vrpnData->valueId));
 
  int vec = MMmalloc(m, 3, TYPETAB);
        if(vec == NIL)
    return MERRMEM;             
 
  MMstore(m, vec, 0, FTOM(vrpnData->vectorData[0]));
  MMstore(m, vec, 1, FTOM(vrpnData->vectorData[1]));
        MMstore(m, vec, 2, FTOM(vrpnData->vectorData[2]));
  MMpush(m, PTOM(vec));
 
  int quat = MMmalloc(m, 4, TYPETAB);
        if(quat == NIL)
    return MERRMEM;             
 
  MMstore(m, quat, 0, FTOM(vrpnData->quatData[0]));
  MMstore(m, quat, 1, FTOM(vrpnData->quatData[1]));
        MMstore(m, quat, 2, FTOM(vrpnData->quatData[2]));
  MMstore(m, quat, 3, FTOM(vrpnData->quatData[3]));
  MMpush(m, PTOM(quat));
 
  // Call reflex previously defined
        int k = OBJcallreflex(m, 3 /*nb param after obj and u0*/);
 
  // free data
  delete(vrpnData);
  return k;
}
 
int _CBvrpnTrackerAccelData(mmachine m)
{
  int vrpnTab = MMget(m, 2);
  int cb = MMget(m, 1);
 
  if (vrpnTab != NIL)
  {
    SVrpn* vrpnObj = MMgetPointer<SVrpn*>(m, MTOP(vrpnTab));
    vrpnObj->EnableTrackerAccelData(cb == NIL ? false : true);
  }
 
        // Add a reflex
        MMechostr(MSKDEBUG, "_CBvrpnTrackerAccelData ...adding reflex\n");
        return OBJaddreflex(m, OBJ_VRPN_SCOL, SCOL_VRPN_TRACKER_ACC_CB);
}
 
int getVRPNTrackerAccelCb(mmachine m, SCOL_PTR_TYPE wParam, SCOL_PTR_TYPE lParam)
{
  SVrpn* vrpnObj = (SVrpn*) wParam;
  SCbData* vrpnData = (SCbData*) lParam;
 
  //call the scol callback
  if (OBJbeginreflex(m, OBJ_VRPN_SCOL, SCOL_PTR vrpnObj, SCOL_VRPN_TRACKER_ACC_CB))
  {
                MMechostr(MSKDEBUG, "ObjVRPN callback not found\n");
    delete(vrpnData);
                return 0;
  }
 
  MMpush(m, ITOM(vrpnData->valueId));
 
  int vec = MMmalloc(m, 3, TYPETAB);
        if(vec == NIL)
    return MERRMEM;             
 
  MMstore(m, vec, 0, FTOM(vrpnData->vectorData[0]));
  MMstore(m, vec, 1, FTOM(vrpnData->vectorData[1]));
        MMstore(m, vec, 2, FTOM(vrpnData->vectorData[2]));
  MMpush(m, PTOM(vec));
 
  int quat = MMmalloc(m, 4, TYPETAB);
        if(quat == NIL)
    return MERRMEM;             
 
  MMstore(m, quat, 0, FTOM(vrpnData->quatData[0]));
  MMstore(m, quat, 1, FTOM(vrpnData->quatData[1]));
        MMstore(m, quat, 2, FTOM(vrpnData->quatData[2]));
  MMstore(m, quat, 3, FTOM(vrpnData->quatData[3]));
  MMpush(m, PTOM(quat));
 
  // Call reflex previously defined
        int k = OBJcallreflex(m, 3 /*nb param after obj and u0*/);
 
  // free data
  delete(vrpnData);
  return k;
}
 
int _CBvrpnTextData(mmachine m)
{
  int vrpnTab = MMget(m, 2);
  int cb = MMget(m, 1);
 
  if (vrpnTab != NIL)
  {
    SVrpn* vrpnObj = MMgetPointer<SVrpn*>(m, MTOP(vrpnTab));
    vrpnObj->EnableTextData(cb == NIL ? false : true);
  }
 
        // Add a reflex
        MMechostr(MSKDEBUG, "_CBvrpnTextData ...adding reflex\n");
        return OBJaddreflex(m, OBJ_VRPN_SCOL, SCOL_VRPN_TEXT_CB);
}
 
int getVRPNTextCb(mmachine m, SCOL_PTR_TYPE wParam, SCOL_PTR_TYPE lParam)
{
  SVrpn* vrpnObj = (SVrpn*) wParam;
  SCbData* vrpnData = (SCbData*) lParam;
 
  //call the scol callback
  if (OBJbeginreflex(m, OBJ_VRPN_SCOL, SCOL_PTR vrpnObj, SCOL_VRPN_TEXT_CB))
  {
                MMechostr(MSKDEBUG, "ObjVRPN callback not found\n");
    delete(vrpnData);
                return 0;
  }
 
  Mpushstrbloc(m, (char*)vrpnData->textData.c_str());
 
  // Call reflex previously defined
        int k = OBJcallreflex(m, 1 /*nb param after obj and u0*/);
 
  // free data
  delete(vrpnData);
  return k;
}
 
// Scol / Package **************************************************************
static NativeDefinition svrpnDef[] =
{
  { "ObjVRPN",                     TYPTYPE,  NULL,                                                                   NULL },
  { "_CRvrpnDevice",               3,        "fun [Chn S S] ObjVRPN",                                                _CRvrpnDevice },
  { "_DSvrpnDevice",               1,        "fun [ObjVRPN] I",                                                      _DSvrpnDevice },
  { "_CBvrpnAnalogData",           3,        "fun [ObjVRPN fun [ObjVRPN u0 [F r1]] u1 u0] ObjVRPN",                  _CBvrpnAnalogData },
  { "_CBvrpnButtonData",           3,        "fun [ObjVRPN fun [ObjVRPN u0 [I r1]] u1 u0] ObjVRPN",                  _CBvrpnButtonData },
  { "_CBvrpnButtonState",          3,        "fun [ObjVRPN fun [ObjVRPN u0 I I] u1 u0] ObjVRPN",                     _CBvrpnButtonState },
  { "_CBvrpnTrackerData",          3,        "fun [ObjVRPN fun [ObjVRPN u0 I [F F F] [F F F F]] u1 u0] ObjVRPN",     _CBvrpnTrackerData },
  { "_CBvrpnTrackerVelocityData",  3,        "fun [ObjVRPN fun [ObjVRPN u0 I [F F F] [F F F F]] u1 u0] ObjVRPN",     _CBvrpnTrackerVelocityData },
  { "_CBvrpnTrackerAccelData",     3,        "fun [ObjVRPN fun [ObjVRPN u0 I [F F F] [F F F F]] u1 u0] ObjVRPN",     _CBvrpnTrackerAccelData },
  { "_CBvrpnTextData",             3,        "fun [ObjVRPN fun [ObjVRPN u0 S] u1 u0] ObjVRPN",                       _CBvrpnTextData }
};
 
// Everything inside _cond and _endcond is ignored by doxygen
 
int LoadVRPN(mmachine m)
{
        int k = 0;
  
        MMechostr(MSKDEBUG,"\n" );
  MMechostr(MSKDEBUG," > Loading VRPN Support\n");
 
  // Declare a new type of object ("ObjVRPN")
        OBJ_VRPN_SCOL = OBJregister(8 /*nb of callback*/, 1, destroyVRPNObj, "OBJ_VRPN_SCOL");
 
  k = PKhardpak2(m, "mVRPN.pkg-1.0", sizeof(svrpnDef) / sizeof(svrpnDef[0]), svrpnDef);
        
  // Register callbacks
  VRPN_ANALOG_CB = OBJgetUserEvent();
        OBJdefEvent(VRPN_ANALOG_CB, getVRPNAnalogCb);
 
  VRPN_BTN_CB = OBJgetUserEvent();
        OBJdefEvent(VRPN_BTN_CB, getVRPNBtnCb);
 
  VRPN_BTN_STATE_CB = OBJgetUserEvent();
        OBJdefEvent(VRPN_BTN_STATE_CB, getVRPNBtnStateCb);
 
  VRPN_TEXT_CB = OBJgetUserEvent();
        OBJdefEvent(VRPN_TEXT_CB, getVRPNTextCb);
 
  VRPN_TRACKER_CB = OBJgetUserEvent();
        OBJdefEvent(VRPN_TRACKER_CB, getVRPNTrackerCb);
  
  VRPN_TRACKER_VEL_CB = OBJgetUserEvent();
        OBJdefEvent(VRPN_TRACKER_VEL_CB, getVRPNTrackerVelocityCb);
 
  VRPN_TRACKER_ACC_CB = OBJgetUserEvent();
        OBJdefEvent(VRPN_TRACKER_ACC_CB, getVRPNTrackerAccelCb);
 
  /*VRPN_DIAL_CB = OBJgetUserEvent();
        OBJdefEvent(VRPN_DIAL_CB, getVRPNDialCb);*/
 
  MMechostr(MSKDEBUG," > Successfully Loaded\n\n");
        return k;
}
 
int CloseVRPN()
{
  MMechostr(MSKDEBUG,"\n" );
  MMechostr(MSKDEBUG," > Unloading VRPN Support\n");
 
  // nothing to do
  
  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 ScolSvrpnLoadPlugin(mmachine m, cbmachine w)
#endif
{
  SCOLinitplugin(w);
  return LoadVRPN(m);
}
 
#ifndef SCOL_STATIC
extern "C" SCOL_EXPORT int ScolUnloadPlugin()
#else
extern "C" SCOL_EXPORT int ScolSvrpnUnloadPlugin()
#endif
{
  return CloseVRPN();
}