scolplugin.cpp

Go to the documentation of this file.

/*
-----------------------------------------------------------------------------
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
 
-----------------------------------------------------------------------------
*/
 
/*
 XInput dll for scol
 First version : may 2010
 Author : Bastien BOURINEAU
*/
 
#include "Joypad.h"
 
#ifdef SCOL_STATIC
extern cbmachine ww;
extern mmachine mm;
#else
cbmachine       ww;
mmachine mm;
#endif
 
#if !defined(_WIN32) && !defined (ANDROID)
extern int(*CallMainThread)(void*, mmachine m);
#endif
 
int OBJJOYPADSCOL;
 
int JOYPAD_DATA_CB;
int SCOL_JOYPAD_DATA_CB = 0;
 
 
#ifdef ANDROID
AInputQueue* AndroidInputQueue;
#endif
 
int destroyJoypadObj(mmachine m, SCOL_PTR_TYPE handsys, int handscol)
{
  Joypad* joypad = MMgetPointer<Joypad*>(m, MTOP(handscol));
  SAFE_DELETE(joypad);
 
  MMsetPointer<Joypad*>(m, MTOP(handscol), 0);
 
        // Display debug message
        MMechostr(MSKDEBUG,"Joypad object destroyed.\n");
        return 0;
}
 
 
#if defined(_WIN32) || defined (ANDROID)
int _OpenJoypad(mmachine m)
#else
int _OpenJoypadSync(mmachine m)
#endif
{
#ifdef _SCOL_DEBUG_
        MMechostr(0,"_OpenJoypad\n");
#endif
        // Declare local variables
        int k = 0;
 
        // Get the channel without pulling it (first element in the stack)
        int pUser = MMget(m, 0);
  int cbfun = MMget(m, 1);
  int channel = MMget(m, 2);
 
        // Test the channel
        if (channel == NIL || cbfun == NIL)
  {
                MMechostr(MSKDEBUG, "Channel NIL\n");
    SEDROP(m, 2); MMset(m, 0, NIL);
                return 0;
        }
 
  Joypad* joypad = new Joypad();
  if (joypad == NULL || (joypad->IsRunning() == false))
  {
                MMechostr(MSKDEBUG,"joypad failed\n");
                SAFE_DELETE(joypad);
    SEDROP(m, 2); MMset(m, 0, NIL);
    return 0;
        }
 
  // re-push channel to create object
  if ((k = MMpush(m, MMget(m, 2))))
    return k; //channel
 
        // Allocate a space in the stack for a table of joypad object
  if ((MMpushPointer(m, joypad) != 0))
  {
    SAFE_DELETE(joypad);
    MMset(m, 0, NIL);
    return MERRMEM;
  }
 
        // Create a new scol joypad object
        k = OBJcreate(m, OBJJOYPADSCOL, SCOL_PTR joypad, NIL, 0);
 
  /* add reflex */
  if ((k = MMpush(m, MMget(m, 2))))
    return k; /* reading callback */
  if ((k = MMpush(m, MMget(m, 2))))
    return k; /* user param       */
  if ((k = OBJaddreflex(m, OBJJOYPADSCOL, SCOL_JOYPAD_DATA_CB)))
    return k;
 
  k = MMpull(m); /* save joypad object */
  m->pp+=3;
 
#ifdef  _SCOL_DEBUG_
        MMechostr(0,"ok\n");
#endif
 
        return MMpush(m, k);
}
 
#if defined(_WIN32) || defined (ANDROID)
int _OpenJoypadEx(mmachine m)
#else
int _OpenJoypadExSync(mmachine m)
#endif
{
#ifdef _SCOL_DEBUG_
  MMechostr(0, "_OpenJoypadEx\n");
#endif
  // Declare local variables
  int k = 0;
 
  // Get the channel without pulling it (first element in the stack)
  int pUser = MMpull(m);
  int cbfun = MMpull(m);
  int sIndex = MTOI(MMpull(m));
  int channel = MMget(m, 0);
 
  // Test the channel
  if (channel == NIL || cbfun == NIL)
  {
    MMechostr(MSKDEBUG, "Channel NIL\n");
    MMset(m, 0, NIL);
    return 0;
  }
 
  Joypad* joypad = new Joypad(sIndex);
  if (joypad == NULL || (joypad->IsRunning() == false))
  {
    MMechostr(MSKDEBUG, "joypad failed\n");
    SAFE_DELETE(joypad);
    MMset(m, 0, NIL);
    return 0;
  }
 
  //restore stack
  MMpush(m, cbfun);
  MMpush(m, pUser);
 
  // re-push channel to create object
  if ((k = MMpush(m, MMget(m, 2))))
    return k; //channel
 
  // Allocate a space in the stack for a table of joypad object
  if ((MMpushPointer(m, joypad) != 0))
  {
    SAFE_DELETE(joypad);
    MMset(m, 0, NIL);
    return MERRMEM;
  }
 
  // Create a new scol joypad object
  k = OBJcreate(m, OBJJOYPADSCOL, SCOL_PTR joypad, NIL, 0);
 
  /* add reflex */
  if ((k = MMpush(m, MMget(m, 2))))
    return k; /* reading callback */
  if ((k = MMpush(m, MMget(m, 2))))
    return k; /* user param       */
  if ((k = OBJaddreflex(m, OBJJOYPADSCOL, SCOL_JOYPAD_DATA_CB)))
    return k;
 
  k = MMpull(m); /* save joypad object */
  m->pp += 3;
 
#ifdef  _SCOL_DEBUG_
  MMechostr(0, "ok\n");
#endif
 
  return MMpush(m, k);
}
 
#if !defined(_WIN32) && !defined (ANDROID)
int _OpenJoypad(mmachine m)
{
  return CallMainThread((void*)_OpenJoypadSync, m);
}
 
int _OpenJoypadEx(mmachine m)
{
  return CallMainThread((void*)_OpenJoypadExSync, m);
}
#endif
 
int _CloseJoypad(mmachine m)
{
#ifdef  _SCOL_DEBUG_
        MMechostr(MSKDEBUG,"_CloseJoypad\n");
#endif
 
        int joypad = MMget(m, 0);
        if (joypad == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
        OBJdelTM(m, OBJJOYPADSCOL, joypad);
        MMset(m, 0, ITOM(0));
 
#ifdef  _SCOL_DEBUG_
        MMechostr(MSKDEBUG,"ok\n");
#endif
        return 0;
}
 
int _StartJoypadRumble(mmachine m)
{
#ifdef  _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "_StartJoypadRumble\n");
#endif
 
  int iintensity = MMpull(m);
  int idevice = MMget(m, 0);
  if (idevice == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  Joypad* joypad = MMgetPointer<Joypad*>(m, MTOP(idevice));
  if (joypad == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  float intensity = 0.5f;
  if (intensity != NIL)
    intensity = MTOF(iintensity);
 
  joypad->StartRumble(intensity);
  MMset(m, 0, ITOM(0));
 
#ifdef  _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "ok\n");
#endif
  return 0;
}
 
int _StopJoypadRumble(mmachine m)
{
#ifdef  _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "_StopJoypadRumble\n");
#endif
 
  int idevice = MMget(m, 0);
  if (idevice == NIL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  Joypad* joypad = MMgetPointer<Joypad*>(m, MTOP(idevice));
  if (joypad == NULL)
  {
    MMset(m, 0, NIL);
    return 0;
  }
 
  joypad->StopRumble();
  MMset(m, 0, ITOM(0));
 
#ifdef  _SCOL_DEBUG_
  MMechostr(MSKDEBUG, "ok\n");
#endif
  return 0;
}
 
int getJoypadData(mmachine m, SCOL_PTR_TYPE id, SCOL_PTR_TYPE param)
{
        int k = 0;
 
        // Cast id parameter to Joypad type
        Joypad * joypad = (Joypad*) id;
  DIJOYSTATE2* ndata = (DIJOYSTATE2*)param;
 
        // Use : OBJbeginreflex(mmachine, type of object, ptr object, callback type)
  if (OBJbeginreflex(m, OBJJOYPADSCOL, SCOL_PTR joypad, SCOL_JOYPAD_DATA_CB))
  {
                MMechostr(MSKDEBUG,"Joypad not found\n");
                return 0;
        }
 
        int tuple = MMmalloc(m, 2, TYPETAB);
        if(tuple==NIL)
  {
    MMpush(m,NIL);
    return MERRMEM;
  }
 
  MMstore(m, tuple, 0, ITOM(ndata->lX));
        MMstore(m, tuple, 1, ITOM(ndata->lY));
 
  MMpush(m, PTOM(tuple));
  MMpush(m, ITOM(ndata->lZ));
 
        int tuple2 = MMmalloc(m, 2, TYPETAB);
        if(tuple2==NIL)
  {
    MMpush(m, NIL);
    return MERRMEM;
  }
        MMstore(m, tuple2, 0, ITOM(ndata->lRx));
        MMstore(m, tuple2, 1, ITOM(ndata->lRy));
 
  MMpush(m,PTOM(tuple2));
  MMpush(m,ITOM(ndata->lRz));
 
        int tuple3 = MMmalloc(m, 4, TYPETAB);
        if(tuple3==NIL)
  {
    MMpush(m, NIL);
    return MERRMEM;
  }
        MMstore(m, tuple3, 0, ITOM(ndata->rgdwPOV[0]));
        MMstore(m, tuple3, 1, ITOM(ndata->rgdwPOV[1]));
  MMstore(m, tuple3, 2, ITOM(ndata->rgdwPOV[2]));
  MMstore(m, tuple3, 3, ITOM(ndata->rgdwPOV[3]));
 
  MMpush(m,PTOM(tuple3));
 
        int tuple4 = MMmalloc(m, 2, TYPETAB);
        if(tuple4==NIL)
  {
    MMpush(m, NIL);
    return MERRMEM;
  }
        MMstore(m, tuple4, 0, ITOM(ndata->rglSlider[0]));
        MMstore(m, tuple4, 1, ITOM(ndata->rglSlider[1]));
 
  MMpush(m,PTOM(tuple4));
 
  // get which buttons are pressed
  for (int i = 0; i < 16; i++)
  {
#ifdef _WIN32
    if( ndata->rgbButtons[i] & 0x80 )
#else
    if (ndata->rgbButtons[i] == 1)
#endif
    {
      if(MMpush(m,ITOM(1)))
        return MERRMEM;
    }
    else
    {
      if(MMpush(m,ITOM(0)))
        return MERRMEM;
    }
  }
 
        if(MMpush(m, NIL))
    return MERRMEM;
 
        for(int i = 0; i < 16; i++)
        {
    if(MMpush(m,2*2))
      return MERRMEM;
                if((k=MBdeftab(m)))
      return k;
        }
 
        // Call reflex previously defined
        k = OBJcallreflex(m, 7 /*nb param after obj and u0*/);
  delete ndata;
        return k;
}
 
static NativeDefinition sJoypadDef[] =
{
  { "ObjJoypad",          TYPTYPE,    NULL,                                                                                     NULL },
  { "_OpenJoypad",        3,                        "fun [Chn fun [ObjJoypad u0 [I I] I [I I] I [I I I I] [I I] [I r1]] u1 u0] ObjJoypad",    _OpenJoypad },
  { "_OpenJoypadEx",      4,                        "fun [Chn I fun [ObjJoypad u0 [I I] I [I I] I [I I I I] [I I] [I r1]] u1 u0] ObjJoypad",  _OpenJoypadEx },
  { "_CloseJoypad",       1,                        "fun [ObjJoypad] I",                                                                      _CloseJoypad },
  { "_StartJoypadRumble", 2,                        "fun [ObjJoypad F] I",                                                                    _StartJoypadRumble },
  { "_StopJoypadRumble",  1,                        "fun [ObjJoypad] I",                                                                      _StopJoypadRumble }
};
 
// Everything inside _cond and _endcond is ignored by doxygen
 
int LoadJoypad(mmachine m)
{
        MMechostr(MSKDEBUG,"\n" );
  MMechostr(MSKDEBUG," > Loading Joypad Support\n");
 
#if !defined(_WIN32) && !defined (ANDROID)
  CallMainThread=(int (__cdecl *)(void*, mmachine))SCgetExtra("callMainThread");
#endif
 
  // Declare a new type of object ("ObjJoypad")
        OBJJOYPADSCOL = OBJregister(1 /*nb of callback*/, 1, destroyJoypadObj, "OBJJOYPADSCOL");
 
        // ----- Define callbacks
        // Get a new user event
        JOYPAD_DATA_CB = OBJgetUserEvent();
        // Associate this event with a callback
        OBJdefEvent(JOYPAD_DATA_CB, getJoypadData);
 
  int k = PKhardpak2(m, "JoypadEngine.pkg-1.0", sizeof(sJoypadDef) / sizeof(sJoypadDef[0]), sJoypadDef);
 
#ifdef ANDROID
  AndroidInputQueue = (AInputQueue*)SCgetExtra("inputQueue");
#endif
 
  MMechostr(MSKDEBUG," > Successfully Loaded\n\n");
        return k;
}
 
 
#ifndef SCOL_STATIC
extern "C" SCOL_EXPORT int ScolLoadPlugin(mmachine m, cbmachine w)
#else
extern "C" SCOL_EXPORT int ScolJoypadLoadPlugin(mmachine m, cbmachine w)
#endif
{
  SCOLinitplugin(w);
        return LoadJoypad(m);
}
 
 
#ifndef SCOL_STATIC
extern "C" SCOL_EXPORT int ScolUnloadPlugin()
#else
extern "C" SCOL_EXPORT int ScolJoypadUnloadPlugin()
#endif
{
        return 0;
}
 
#ifndef SCOL_STATIC
extern "C" SCOL_EXPORT void ScolHandleWindowEventPlugin(mmachine m, SCOL_PTR_TYPE event, int wparam, int lparam)
#else
extern "C" SCOL_EXPORT void ScolJoypadHandleWindowEventPlugin(mmachine m, SCOL_PTR_TYPE event, int wparam, int lparam)
#endif
{
#ifdef ANDROID
  Joypad::updateInputEvent((AInputEvent*)event);
#endif
}