void LUA_STOP_COMMAND_CALLBACK(SLuaCallBack* p)
{ // the callback function of the new Lua command
int result=-1; // error
if (p->inputArgCount>0)
{ // Ok, we have at least 1 input argument
if (p->inputArgTypeAndSize[0*2+0]==sim_lua_arg_int)
{ // Ok, we have (at least) 1 int as argument
CSimxSocket* s=allConnections.getConnectionFromPort(p->inputInt[0]);
if ( (s!=NULL)&&s->getActiveOnlyDuringSimulation() )
{
allConnections.removeSocketConnection(s);
result=1;
}
else
simSetLastError(LUA_STOP_COMMAND,"Invalid port number."); // output an error
}
else
simSetLastError(LUA_STOP_COMMAND,"Wrong argument type/size."); // output an error
}
else
simSetLastError(LUA_STOP_COMMAND,"Not enough arguments."); // output an error
// Now we prepare the return value:
p->outputArgCount=1; // 1 return value
p->outputArgTypeAndSize=(simInt*)simCreateBuffer(p->outputArgCount*2*sizeof(simInt)); // x return values takes x*2 simInt for the type and size buffer
p->outputArgTypeAndSize[2*0+0]=sim_lua_arg_int; // The return value is an int
p->outputArgTypeAndSize[2*0+1]=1; // Not used (table size if the return value was a table)
p->outputInt=(simInt*)simCreateBuffer(1*sizeof(result)); // 1 int return value
p->outputInt[0]=result; // This is the int value we want to return
}
VREP_DLLEXPORT void v_repDecimateMesh(void* data)
{
// Collect info from V-REP:
void** valPtr=(void**)data;
float* verticesIn=((float*)valPtr[0]);
int verticesInLength=((int*)valPtr[1])[0];
int* indicesIn=((int*)valPtr[2]);
int indicesInLength=((int*)valPtr[3])[0];
float decimationPercentage=((float*)valPtr[4])[0];
int interfaceVersion=((int*)valPtr[5])[0]; // should be zero for the current version
std::vector<float> verticesOut;
std::vector<int> indicesOut;
bool result=compute(verticesIn,verticesInLength,indicesIn,indicesInLength,decimationPercentage,verticesOut,indicesOut);
((bool*)valPtr[6])[0]=result;
if (result)
{
float* v=(float*)simCreateBuffer(verticesOut.size()*sizeof(float));
for (size_t i=0;i<verticesOut.size();i++)
v[i]=verticesOut[i];
((float**)valPtr[7])[0]=v;
((int*)valPtr[8])[0]=verticesOut.size();
int* ind=(int*)simCreateBuffer(indicesOut.size()*sizeof(int));
for (size_t i=0;i<indicesOut.size();i++)
ind[i]=indicesOut[i];
((int**)valPtr[9])[0]=ind;
((int*)valPtr[10])[0]=indicesOut.size();
}
}
void LUA_END_CALLBACK(SLuaCallBack* p)
{ // the callback function of the new Lua command
simLockInterface(1);
int result=-1; // error
if (p->inputArgCount>0)
{ // Ok, we have at least 1 input argument
if (p->inputArgTypeAndSize[0*2+0]==sim_lua_arg_int)
{ // Ok, we have (at least) 1 int as argument
if ( (p->inputInt[0]>=0)&&(p->inputInt[0]<4)&&(startCountPerDevice[p->inputInt[0]]>0) )
{
startCountOverall--;
startCountPerDevice[p->inputInt[0]]--;
if (startCountPerDevice[p->inputInt[0]]==0)
{ // No one is using this device anymore... we remove it
EnterCriticalSection(&m_cs);
_allDevices[p->inputInt[0]]->Disconnect();
delete _allDevices[p->inputInt[0]];
_allDevices[p->inputInt[0]]=NULL;
LeaveCriticalSection(&m_cs);
}
if (startCountOverall==0)
killThread();
result=1;
}
else
simSetLastError(LUA_END,"Invalid device index."); // output an error
}
else
simSetLastError(LUA_END,"Wrong argument type/size."); // output an error
}
else
simSetLastError(LUA_END,"Not enough arguments."); // output an error
// Now we prepare the return value:
p->outputArgCount=1; // 1 return value
p->outputArgTypeAndSize=(simInt*)simCreateBuffer(p->outputArgCount*2*sizeof(simInt)); // x return values takes x*2 simInt for the type and size buffer
p->outputArgTypeAndSize[2*0+0]=sim_lua_arg_int; // The return value is an int
p->outputArgTypeAndSize[2*0+1]=1; // Not used (table size if the return value was a table)
p->outputInt=(simInt*)simCreateBuffer(1*sizeof(result)); // 1 int return value
p->outputInt[0]=result; // This is the int value we want to return
simLockInterface(0);
}
VREP_DLLEXPORT simChar* v_repImportUrdf(simChar* filenameOrUrdf, simBool hideCollisionLinks, simBool hideJoints, simBool convexDecomposeNonConvexCollidables, simBool createVisualIfNone, simBool showConvexDecompositionDlg, simBool centerAboveGround, simBool makeModel, simBool noSelfCollision, simBool positionCtrl) {
robot Robot(filenameOrUrdf, hideCollisionLinks, hideJoints, convexDecomposeNonConvexCollidables, createVisualIfNone, showConvexDecompositionDlg, centerAboveGround, makeModel, noSelfCollision, positionCtrl);
simChar* result = (simChar*)simCreateBuffer(Robot.name.length()+1);
memcpy((void*) result, (void*) Robot.name.c_str(), Robot.name.length()+1);
return result;
}
void LUA_RESET_COMMAND_CALLBACK(SLuaCallBack* p)
{ // the callback function of the new Lua command
int result=-1; // error
if (p->inputArgCount>0)
{ // Ok, we have at least 1 input argument
if (p->inputArgTypeAndSize[0*2+0]==sim_lua_arg_int)
{ // Ok, we have (at least) 1 int as argument
CSimxSocket* s=allConnections.getConnectionFromPort(p->inputInt[0]);
if (s!=NULL)
{
bool simulOnly=s->getActiveOnlyDuringSimulation();
bool debug=s->getDebug();
int maxPacketS=s->getMaxPacketSize();
bool triggerPreEnabled=s->getWaitForTriggerAuthorized();
// Kill the thread/connection:
allConnections.removeSocketConnection(s);
// Now create a similar thread/connection:
CSimxSocket* oneSocketConnection=new CSimxSocket(p->inputInt[0],simulOnly,debug,maxPacketS,triggerPreEnabled);
oneSocketConnection->start();
allConnections.addSocketConnection(oneSocketConnection);
result=1;
}
else
simSetLastError(LUA_RESET_COMMAND,"Invalid port number."); // output an error
}
else
simSetLastError(LUA_RESET_COMMAND,"Wrong argument type/size."); // output an error
}
else
simSetLastError(LUA_RESET_COMMAND,"Not enough arguments."); // output an error
// Now we prepare the return value:
p->outputArgCount=1; // 1 return value
p->outputArgTypeAndSize=(simInt*)simCreateBuffer(p->outputArgCount*2*sizeof(simInt)); // x return values takes x*2 simInt for the type and size buffer
p->outputArgTypeAndSize[2*0+0]=sim_lua_arg_int; // The return value is an int
p->outputArgTypeAndSize[2*0+1]=1; // Not used (table size if the return value was a table)
p->outputInt=(simInt*)simCreateBuffer(1*sizeof(result)); // 1 int return value
p->outputInt[0]=result; // This is the int value we want to return
}
void LUA_END_CALLBACK(SLuaCallBack* p)
{ // the callback function of the new Lua command
int result=-1; // error
if (p->inputArgCount>0)
{ // Ok, we have at least 1 input argument
if (p->inputArgTypeAndSize[0*2+0]==sim_lua_arg_int)
{ // Ok, we have (at least) 1 int as argument
if ( (p->inputInt[0]<4)&&(startCountPerDevice[p->inputInt[0]]>0) )
{
startCountOverall--;
startCountPerDevice[p->inputInt[0]]--;
if (startCountPerDevice[p->inputInt[0]]==0)
{
EnterCriticalSection(&m_cs);
deinitCapture(p->inputInt[0]);
delete[] captureInfo[p->inputInt[0]].mTargetBuf;
openCaptureDevices[p->inputInt[0]]=false;
LeaveCriticalSection(&m_cs);
}
if (startCountOverall==0)
killThread();
result=1;
}
else
simSetLastError(LUA_END,"Invalid device index."); // output an error
}
else
simSetLastError(LUA_END,"Wrong argument type/size."); // output an error
}
else
simSetLastError(LUA_END,"Not enough arguments."); // output an error
// Now we prepare the return value:
p->outputArgCount=1; // 1 return value
p->outputArgTypeAndSize=(simInt*)simCreateBuffer(p->outputArgCount*2*sizeof(simInt)); // x return values takes x*2 simInt for the type and size buffer
p->outputArgTypeAndSize[2*0+0]=sim_lua_arg_int; // The return value is an int
p->outputArgTypeAndSize[2*0+1]=1; // Not used (table size if the return value was a table)
p->outputInt=(simInt*)simCreateBuffer(1*sizeof(result)); // 1 int return value
p->outputInt[0]=result; // This is the int value we want to return
}
void v_repImportUrdfCallback(SLuaCallBack* p)
{
if (p->inputArgCount == 10) {
simChar* name = v_repImportUrdf(p->inputChar,p->inputBool[0],p->inputBool[1],p->inputBool[2],p->inputBool[3],
p->inputBool[4],p->inputBool[5],p->inputBool[6],p->inputBool[7],p->inputBool[8]);
p->outputArgCount = 1;
p->outputArgTypeAndSize = (simInt*)simCreateBuffer(p->outputArgCount*2*sizeof(simInt));
p->outputArgTypeAndSize[0] = sim_lua_arg_string;
p->outputArgTypeAndSize[1] = 1;
p->outputChar = (simChar*)simCreateBuffer(strlen(name)+1);
memcpy((void*)p->outputChar, (void*)name, strlen(name)+1);
} else {
simSetLastError("simExtImportUrdfCallback","Wrong number of arguments.");
p->outputArgCount = 0;
}
}
void LUA_INFO_CALLBACK(SLuaCallBack* p)
{ // the callback function of the new Lua command
char infoString[200];
infoString[0]=0;
if (p->inputArgCount>0)
{ // Ok, we have at least 1 input argument
if (p->inputArgTypeAndSize[0*2+0]==sim_lua_arg_int)
{ // Ok, we have (at least) one int as argument
if ( (countCaptureDevices()>p->inputInt[0])&&(p->inputInt[0]>=0)&&(p->inputInt[0]<4) )
{
getCaptureDeviceName(p->inputInt[0],infoString,200);
}
else
simSetLastError(LUA_INFO,"Wrong index."); // output an error
}
else
simSetLastError(LUA_INFO,"Wrong argument type/size."); // output an error
}
else
simSetLastError(LUA_INFO,"Not enough arguments."); // output an error
// Now we prepare the return value:
int l=int(strlen(infoString));
if (l!=0)
{
p->outputArgCount=1; // 1 return value
p->outputArgTypeAndSize=(simInt*)simCreateBuffer(p->outputArgCount*2*sizeof(simInt)); // x return values takes x*2 simInt for the type and size buffer
p->outputArgTypeAndSize[2*0+0]=sim_lua_arg_string; // The return value is a string
p->outputArgTypeAndSize[2*0+1]=1; // Not used (table size if the return value was a table)
p->outputChar=(simChar*)simCreateBuffer(l+1); // 1 string return value
for (int i=0;i<l;i++)
p->outputChar[i]=infoString[i];
p->outputChar[l]=0;
}
else
p->outputArgCount=0; // no return values (nil)
}
void LUA_SET_CALLBACK(SLuaCallBack* p)
{ // the callback function of the new Lua command
simLockInterface(1);
int result=-1; // error
if (p->inputArgCount>2)
{ // Ok, we have at least 3 input argument
if ( (p->inputArgTypeAndSize[0*2+0]==sim_lua_arg_int)&&(p->inputArgTypeAndSize[1*2+0]==sim_lua_arg_int)&&(p->inputArgTypeAndSize[2*2+0]==sim_lua_arg_bool) )
{ // Ok, we have (at least) 2 ints and a bool as argument
if ( (p->inputInt[0]>=0)&&(p->inputInt[0]<4)&&(startCountPerDevice[p->inputInt[0]]>0) )
{ // Ok, we have an "open" device here
_allDeviceData[p->inputInt[0]].leds=BYTE(p->inputInt[1]);
_allDeviceData[p->inputInt[0]].rumble=(p->inputBool[1]!=0);
result=1;
}
else
simSetLastError(LUA_SET,"Invalid device index."); // output an error
}
else
simSetLastError(LUA_SET,"Wrong argument type/size."); // output an error
}
else
simSetLastError(LUA_SET,"Not enough arguments."); // output an error
// Now we prepare the return value:
p->outputArgCount=1; // 1 return value
p->outputArgTypeAndSize=(simInt*)simCreateBuffer(p->outputArgCount*2*sizeof(simInt)); // x return values takes x*2 simInt for the type and size buffer
p->outputArgTypeAndSize[2*0+0]=sim_lua_arg_int; // The return value is an int
p->outputArgTypeAndSize[2*0+1]=1; // Not used (table size if the return value was a table)
p->outputInt=(simInt*)simCreateBuffer(1*sizeof(result)); // 1 int return value
p->outputInt[0]=result; // This is the int value we want to return
simLockInterface(0);
}
void LUA_STATUS_COMMAND_CALLBACK(SLuaCallBack* p)
{ // the callback function of the new Lua command
int result=-1; // error or no connection at given index
int info[5];
int clientVersion=-1;
if (p->inputArgCount>0)
{ // Ok, we have at least 1 input argument
if (p->inputArgTypeAndSize[0*2+0]==sim_lua_arg_int)
{ // Ok, we have (at least) 1 int as argument
CSimxSocket* s=allConnections.getConnectionFromPort(p->inputInt[0]);
// CSimxSocket* s=allConnections.getConnectionAtIndex(p->inputInt[0]);
if (s!=NULL)
{
result=s->getStatus();
s->getInfo(info);
clientVersion=s->getClientVersion();
}
}
else
simSetLastError(LUA_STATUS_COMMAND,"Wrong argument type/size."); // output an error
}
else
simSetLastError(LUA_STATUS_COMMAND,"Not enough arguments."); // output an error
// Now we prepare the return value:
if (result>-1)
{
p->outputArgCount=4; // 4 return values
p->outputArgTypeAndSize=(simInt*)simCreateBuffer(p->outputArgCount*2*sizeof(simInt)); // x return values takes x*2 simInt for the type and size buffer
p->outputArgTypeAndSize[2*0+0]=sim_lua_arg_int; // The return value is an int
p->outputArgTypeAndSize[2*0+1]=1; // Not used (table size if the return value was a table)
p->outputArgTypeAndSize[2*1+0]=sim_lua_arg_int|sim_lua_arg_table; // The return value is an int table
p->outputArgTypeAndSize[2*1+1]=5; // Table size
p->outputArgTypeAndSize[2*2+0]=sim_lua_arg_int; // The return value is an int
p->outputArgTypeAndSize[2*2+1]=1; // Not used (table size if the return value was a table)
p->outputArgTypeAndSize[2*3+0]=sim_lua_arg_int; // The return value is an int
p->outputArgTypeAndSize[2*3+1]=1; // Not used (table size if the return value was a table)
p->outputInt=(simInt*)simCreateBuffer(8*sizeof(result)); // total of 8 ints
p->outputInt[0]=result; // This is the int value we want to return (arg 1)
// Now the table values:
for (int i=0;i<5;i++)
p->outputInt[1+i]=info[i];
p->outputInt[6]=SIMX_VERSION; // This is the server version info (arg 3)
p->outputInt[7]=clientVersion; // This is the client version info (arg 4)
}
else
{
p->outputArgCount=4; // 4 return values
p->outputArgTypeAndSize=(simInt*)simCreateBuffer(p->outputArgCount*2*sizeof(simInt)); // x return values takes x*2 simInt for the type and size buffer
p->outputArgTypeAndSize[2*0+0]=sim_lua_arg_int; // The return value is an int
p->outputArgTypeAndSize[2*0+1]=1; // Not used (table size if the return value was a table)
p->outputArgTypeAndSize[2*1+0]=sim_lua_arg_nil; // The return value is nil
p->outputArgTypeAndSize[2*1+1]=1; // Not used (table size if the return value was a table)
p->outputArgTypeAndSize[2*2+0]=sim_lua_arg_int; // The return value is an int
p->outputArgTypeAndSize[2*2+1]=1; // Not used (table size if the return value was a table)
p->outputArgTypeAndSize[2*3+0]=sim_lua_arg_int; // The return value is an int
p->outputArgTypeAndSize[2*3+1]=1; // Not used (table size if the return value was a table)
p->outputInt=(simInt*)simCreateBuffer(3*sizeof(result)); // 3 int return value
p->outputInt[0]=result; // This is the int value we want to return
p->outputInt[1]=SIMX_VERSION; // This is the second int value we want to return
p->outputInt[2]=clientVersion; // This is the third int value we want to return
}
}
void LUA_START_COMMAND_CALLBACK(SLuaCallBack* p)
{ // the callback function of the new Lua command
int result=-1; // error
if (p->inputArgCount>0)
{ // Ok, we have at least 1 input argument
if (p->inputArgTypeAndSize[0*2+0]==sim_lua_arg_int)
{ // Ok, we have (at least) 1 int as argument
bool err=false;
int maxPacketSize=1300;
if (p->inputInt[0]<0)
maxPacketSize=3200000; // when using shared memory
bool debug=false;
bool triggerPreEnabled=false; // 3/3/2014
if (p->inputArgCount>1)
{
if (p->inputArgTypeAndSize[1*2+0]==sim_lua_arg_int)
{
maxPacketSize=p->inputInt[1];
if (p->inputInt[0]<0)
{ // when using shared memory
if (maxPacketSize<1000)
maxPacketSize=1000;
if (maxPacketSize>32000000)
maxPacketSize=32000000;
}
else
{ // when using sockets
if (maxPacketSize<200)
maxPacketSize=200;
if (maxPacketSize>30000)
maxPacketSize=30000;
}
}
else
err=true;
if (p->inputArgCount>2)
{
if (p->inputArgTypeAndSize[2*2+0]==sim_lua_arg_bool)
debug=(p->inputBool[0]!=0);
else
err=true;
// 3/3/2014
if (p->inputArgCount>3)
{
if (p->inputArgTypeAndSize[3*2+0]==sim_lua_arg_bool)
triggerPreEnabled=(p->inputBool[1]!=0);
else
err=true;
}
}
}
if (!err)
{
CSimxSocket* s=allConnections.getConnectionFromPort(p->inputInt[0]);
if (s==NULL)
{
CSimxSocket* oneSocketConnection=new CSimxSocket(p->inputInt[0],true,debug,maxPacketSize,triggerPreEnabled); // 3/3/2014
oneSocketConnection->start();
allConnections.addSocketConnection(oneSocketConnection);
result=1;
}
else
simSetLastError(LUA_START_COMMAND,"Invalid port number."); // output an error
}
else
simSetLastError(LUA_START_COMMAND,"Wrong argument type/size."); // output an error
}
else
simSetLastError(LUA_START_COMMAND,"Wrong argument type/size."); // output an error
}
else
simSetLastError(LUA_START_COMMAND,"Not enough arguments."); // output an error
// Now we prepare the return value:
p->outputArgCount=1; // 1 return value
p->outputArgTypeAndSize=(simInt*)simCreateBuffer(p->outputArgCount*2*sizeof(simInt)); // x return values takes x*2 simInt for the type and size buffer
p->outputArgTypeAndSize[2*0+0]=sim_lua_arg_int; // The return value is an int
p->outputArgTypeAndSize[2*0+1]=1; // Not used (table size if the return value was a table)
p->outputInt=(simInt*)simCreateBuffer(1*sizeof(result)); // 1 int return value
p->outputInt[0]=result; // This is the int value we want to return
}
void LUA_GRAB_CALLBACK(SLuaCallBack* p)
{ // the callback function of the new Lua command
int retVal=0; // Means error
if (p->inputArgCount>1)
{ // Ok, we have at least 2 input argument
if ( (p->inputArgTypeAndSize[0*2+0]==sim_lua_arg_int)&&(p->inputArgTypeAndSize[1*2+0]==sim_lua_arg_int) )
{ // Ok, we have (at least) 2 ints as argument
if ( (countCaptureDevices()>p->inputInt[0])&&(p->inputInt[0]>=0)&&(p->inputInt[0]<4) )
{
if (startCountPerDevice[p->inputInt[0]]>0)
{
if (openCaptureDevices[p->inputInt[0]])
{
int errorModeSaved;
simGetIntegerParameter(sim_intparam_error_report_mode,&errorModeSaved);
simSetIntegerParameter(sim_intparam_error_report_mode,sim_api_errormessage_ignore);
int t=simGetObjectType(p->inputInt[1]);
simSetIntegerParameter(sim_intparam_error_report_mode,errorModeSaved); // restore previous settings
if (t==sim_object_visionsensor_type)
{
int r[2]={0,0};
simGetVisionSensorResolution(p->inputInt[1],r);
if ( (r[0]==captureInfo[p->inputInt[0]].mWidth)&&(r[1]==captureInfo[p->inputInt[0]].mHeight) )
{
float* buff=new float[r[0]*r[1]*3];
for (int i=0;i<r[1];i++)
{
int y0=r[0]*i;
int y1=r[0]*(r[1]-i-1);
for (int j=0;j<r[0];j++)
{ // Info is provided as BGR!! (and not RGB)
buff[3*(y0+j)+0]=float(((BYTE*)captureInfo[p->inputInt[0]].mTargetBuf)[4*(y1+j)+2])/255.0f;
buff[3*(y0+j)+1]=float(((BYTE*)captureInfo[p->inputInt[0]].mTargetBuf)[4*(y1+j)+1])/255.0f;
buff[3*(y0+j)+2]=float(((BYTE*)captureInfo[p->inputInt[0]].mTargetBuf)[4*(y1+j)+0])/255.0f;
}
}
simSetVisionSensorImage(p->inputInt[1],buff);
delete[] buff;
retVal=1;
}
else
simSetLastError(LUA_GRAB,"Resolutions do not match."); // output an error
}
else
simSetLastError(LUA_GRAB,"Invalid vision sensor handle."); // output an error
}
else
simSetLastError(LUA_GRAB,"Resolution was not set."); // output an error
}
else
simSetLastError(LUA_GRAB,"simExtCamStart was not called."); // output an error
}
else
simSetLastError(LUA_GRAB,"Wrong index."); // output an error
}
else
simSetLastError(LUA_GRAB,"Wrong argument type/size."); // output an error
}
else
simSetLastError(LUA_GRAB,"Not enough arguments."); // output an error
// Now we prepare the return value:
p->outputArgCount=1; // 1 return value
p->outputArgTypeAndSize=(simInt*)simCreateBuffer(p->outputArgCount*2*sizeof(simInt)); // x return values takes x*2 simInt for the type and size buffer
p->outputArgTypeAndSize[2*0+0]=sim_lua_arg_int; // The return value is an int
p->outputArgTypeAndSize[2*0+1]=1; // Not used (table size if the return value was a table)
p->outputInt=(simInt*)simCreateBuffer(1*sizeof(retVal)); // 1 int return value
p->outputInt[0]=retVal; // This is the int value we want to return
}
void LUA_START_CALLBACK(SLuaCallBack* p)
{ // the callback function of the new Lua command
int result=-1; // error
int returnResolution[2]={0,0};
if (p->inputArgCount>2)
{ // Ok, we have at least 3 input argument
if ( (p->inputArgTypeAndSize[0*2+0]==sim_lua_arg_int)&&(p->inputArgTypeAndSize[1*2+0]==sim_lua_arg_int)&&(p->inputArgTypeAndSize[2*2+0]==sim_lua_arg_int) )
{ // Ok, we have (at least) 3 ints as argument
if ( (countCaptureDevices()>p->inputInt[0])&&(p->inputInt[0]>=0)&&(p->inputInt[0]<4) )
{
if (!openCaptureDevices[p->inputInt[0]])
{ // We can set the new resolution
bool goOn=true;
if (startCountOverall==0)
{ // Launch the thread!
_camThreadLaunched=false;
CreateThread(NULL,0,_camThread,NULL,THREAD_PRIORITY_NORMAL,NULL);
while (!_camThreadLaunched)
Sleep(2);
if (deviceCount<1)
{
simSetLastError(LUA_START,"ESCAPI initialization failure or no devices found."); // output an error
killThread();
goOn=false;
}
}
if (goOn)
{
captureInfo[p->inputInt[0]].mWidth=p->inputInt[1];
captureInfo[p->inputInt[0]].mHeight=p->inputInt[2];
captureInfo[p->inputInt[0]].mTargetBuf=new int[p->inputInt[1]*p->inputInt[2]];
if (initCapture(p->inputInt[0],&captureInfo[p->inputInt[0]])!=0)
{
doCapture(p->inputInt[0]);
openCaptureDevices[p->inputInt[0]]=true;
returnResolution[0]=p->inputInt[1];
returnResolution[1]=p->inputInt[2];
result=1; // success!
startCountOverall++;
startCountPerDevice[p->inputInt[0]]++;
}
else
{
delete[] captureInfo[p->inputInt[0]].mTargetBuf;
simSetLastError(LUA_START,"Device may already be in use."); // output an error
}
}
}
else
{ // We have to retrieve the current resolution
returnResolution[0]=captureInfo[p->inputInt[0]].mWidth;
returnResolution[1]=captureInfo[p->inputInt[0]].mHeight;
result=0;
startCountOverall++;
startCountPerDevice[p->inputInt[0]]++;
}
}
else
simSetLastError(LUA_START,"Invalid device index."); // output an error
}
else
simSetLastError(LUA_START,"Wrong argument type/size."); // output an error
}
else
simSetLastError(LUA_START,"Not enough arguments."); // output an error
// Now we prepare the return value:
if (result>-1)
{
p->outputArgCount=3; // 3 return values
p->outputArgTypeAndSize=(simInt*)simCreateBuffer(p->outputArgCount*2*sizeof(simInt)); // x return values takes x*2 simInt for the type and size buffer
p->outputArgTypeAndSize[2*0+0]=sim_lua_arg_int; // The return value is an int
p->outputArgTypeAndSize[2*0+1]=1; // Not used (table size if the return value was a table)
p->outputArgTypeAndSize[2*1+0]=sim_lua_arg_int; // The return value is an int
p->outputArgTypeAndSize[2*1+1]=1; // Not used (table size if the return value was a table)
p->outputArgTypeAndSize[2*2+0]=sim_lua_arg_int; // The return value is an int
p->outputArgTypeAndSize[2*2+1]=1; // Not used (table size if the return value was a table)
p->outputInt=(simInt*)simCreateBuffer(3*sizeof(result)); // 1 int return value
p->outputInt[0]=result; // This is the int value we want to return
p->outputInt[1]=returnResolution[0]; // This is the int value we want to return
p->outputInt[2]=returnResolution[1]; // This is the int value we want to return
}
else
{
p->outputArgCount=1; // 1 return value
p->outputArgTypeAndSize=(simInt*)simCreateBuffer(p->outputArgCount*2*sizeof(simInt)); // x return values takes x*2 simInt for the type and size buffer
p->outputArgTypeAndSize[2*0+0]=sim_lua_arg_int; // The return value is an int
p->outputArgTypeAndSize[2*0+1]=1; // Not used (table size if the return value was a table)
p->outputInt=(simInt*)simCreateBuffer(1*sizeof(result)); // 1 int return value
p->outputInt[0]=result; // This is the int value we want to return
}
}
void CLuaFunctionData::writeDataToLua_luaFunctionCall(SLuaCallBack* p,const int* expectedArguments)
{ // use this when doing a Lua function call from a plugin
p->inputArgCount=0;
p->inputBool=NULL;
p->inputInt=NULL;
p->inputFloat=NULL;
p->inputDouble=NULL;
p->inputChar=NULL;
p->inputCharBuff=NULL;
p->inputArgTypeAndSize=NULL;
p->outputArgCount=expectedArguments[0];
p->outputBool=NULL;
p->outputInt=NULL;
p->outputFloat=NULL;
p->outputDouble=NULL;
p->outputChar=NULL;
p->outputCharBuff=NULL;
p->outputArgTypeAndSize=(simInt*)simCreateBuffer(p->outputArgCount*2*sizeof(simInt));
for (int i=0;i<p->outputArgCount*2;i++)
p->outputArgTypeAndSize[i]=expectedArguments[1+i];
int itemCnt=int(_inData.size());
if (itemCnt>0)
{
p->inputArgCount=itemCnt;
p->inputArgTypeAndSize=(simInt*)simCreateBuffer(p->inputArgCount*2*sizeof(simInt));
int boolDataCnt=0;
int intDataCnt=0;
int floatDataCnt=0;
int doubleDataCnt=0;
int charDataCnt=0;
int charBuffDataCnt=0;
for (int i=0;i<itemCnt;i++)
{
if (_inData[i].isTable())
{ // table
if (_inData[i].getType()==-1)
{
p->inputArgTypeAndSize[i*2+0]=sim_lua_arg_nil|sim_lua_arg_table;
p->inputArgTypeAndSize[i*2+1]=_inData[i].getNilTableSize();
}
if (_inData[i].getType()==0)
{
p->inputArgTypeAndSize[i*2+0]=sim_lua_arg_bool|sim_lua_arg_table;
p->inputArgTypeAndSize[i*2+1]=int(_inData[i].boolData.size());
boolDataCnt+=p->inputArgTypeAndSize[i*2+1];
}
if (_inData[i].getType()==1)
{
p->inputArgTypeAndSize[i*2+0]=sim_lua_arg_int|sim_lua_arg_table;
p->inputArgTypeAndSize[i*2+1]=int(_inData[i].intData.size());
intDataCnt+=p->inputArgTypeAndSize[i*2+1];
}
if (_inData[i].getType()==2)
{
p->inputArgTypeAndSize[i*2+0]=sim_lua_arg_float|sim_lua_arg_table;
p->inputArgTypeAndSize[i*2+1]=int(_inData[i].floatData.size());
floatDataCnt+=p->inputArgTypeAndSize[i*2+1];
}
if (_inData[i].getType()==5)
{
p->inputArgTypeAndSize[i*2+0]=sim_lua_arg_double|sim_lua_arg_table;
p->inputArgTypeAndSize[i*2+1]=int(_inData[i].doubleData.size());
doubleDataCnt+=p->inputArgTypeAndSize[i*2+1];
}
if (_inData[i].getType()==3)
{
p->inputArgTypeAndSize[i*2+0]=sim_lua_arg_string|sim_lua_arg_table;
p->inputArgTypeAndSize[i*2+1]=int(_inData[i].stringData.size());
for (int j=0;j<int(_inData[i].stringData.size());j++)
charDataCnt+=int(_inData[i].stringData[j].length())+1;
}
}
else
{
if (_inData[i].getType()==-1)
{
p->inputArgTypeAndSize[i*2+1]=0;
p->inputArgTypeAndSize[i*2+0]=sim_lua_arg_nil;
}
if (_inData[i].getType()==0)
{
p->inputArgTypeAndSize[i*2+1]=0;
p->inputArgTypeAndSize[i*2+0]=sim_lua_arg_bool;
boolDataCnt++;
}
if (_inData[i].getType()==1)
{
p->inputArgTypeAndSize[i*2+1]=0;
p->inputArgTypeAndSize[i*2+0]=sim_lua_arg_int;
intDataCnt++;
}
if (_inData[i].getType()==2)
{
p->inputArgTypeAndSize[i*2+1]=0;
p->inputArgTypeAndSize[i*2+0]=sim_lua_arg_float;
floatDataCnt++;
}
if (_inData[i].getType()==5)
{
p->inputArgTypeAndSize[i*2+1]=0;
p->inputArgTypeAndSize[i*2+0]=sim_lua_arg_double;
doubleDataCnt++;
}
if (_inData[i].getType()==3)
{
p->inputArgTypeAndSize[i*2+1]=0;
p->inputArgTypeAndSize[i*2+0]=sim_lua_arg_string;
charDataCnt+=int(_inData[i].stringData[0].length())+1;
}
if (_inData[i].getType()==4)
{
p->inputArgTypeAndSize[i*2+1]=int(_inData[i].stringData[0].length());
p->inputArgTypeAndSize[i*2+0]=sim_lua_arg_charbuff;
charBuffDataCnt+=int(_inData[i].stringData[0].length());
}
}
}
// Now create the buffers:
p->inputBool=(simBool*)simCreateBuffer(boolDataCnt*sizeof(simBool));
p->inputInt=(simInt*)simCreateBuffer(intDataCnt*sizeof(simInt));
p->inputFloat=(simFloat*)simCreateBuffer(floatDataCnt*sizeof(simFloat));
p->inputDouble=(simDouble*)simCreateBuffer(doubleDataCnt*sizeof(simDouble));
p->inputChar=(simChar*)simCreateBuffer(charDataCnt*sizeof(simChar));
p->inputCharBuff=(simChar*)simCreateBuffer(charBuffDataCnt*sizeof(simChar));
// Now populate the buffers:
int boolDataOff=0;
int intDataOff=0;
int floatDataOff=0;
int doubleDataOff=0;
int charDataOff=0;
int charBuffDataOff=0;
for (int i=0;i<itemCnt;i++)
{
if (_inData[i].isTable())
{ // table
if (_inData[i].getType()==0)
{
for (int j=0;j<int(_inData[i].boolData.size());j++)
p->inputBool[boolDataOff++]=_inData[i].boolData[j];
}
if (_inData[i].getType()==1)
{
for (int j=0;j<int(_inData[i].intData.size());j++)
p->inputInt[intDataOff++]=_inData[i].intData[j];
}
if (_inData[i].getType()==2)
{
for (int j=0;j<int(_inData[i].floatData.size());j++)
p->inputFloat[floatDataOff++]=_inData[i].floatData[j];
}
if (_inData[i].getType()==5)
{
for (int j=0;j<int(_inData[i].doubleData.size());j++)
p->inputDouble[doubleDataOff++]=_inData[i].doubleData[j];
}
if (_inData[i].getType()==3)
{
for (int j=0;j<int(_inData[i].stringData.size());j++)
{
for (int k=0;k<int(_inData[i].stringData[j].length());k++)
p->inputChar[charDataOff++]=_inData[i].stringData[j][k];
p->inputChar[charDataOff++]=0;
}
}
}
else
{
if (_inData[i].getType()==0)
p->inputBool[boolDataOff++]=_inData[i].boolData[0];
if (_inData[i].getType()==1)
p->inputInt[intDataOff++]=_inData[i].intData[0];
if (_inData[i].getType()==2)
p->inputFloat[floatDataOff++]=_inData[i].floatData[0];
if (_inData[i].getType()==5)
p->inputDouble[doubleDataOff++]=_inData[i].doubleData[0];
if (_inData[i].getType()==3)
{
for (int j=0;j<int(_inData[i].stringData[0].length());j++)
p->inputChar[charDataOff++]=_inData[i].stringData[0][j];
p->inputChar[charDataOff++]=0;
}
if (_inData[i].getType()==4)
{
for (int j=0;j<int(_inData[i].stringData[0].length());j++)
p->inputCharBuff[charBuffDataOff++]=_inData[i].stringData[0][j];
}
}
}
}
}
void LUA_GET_CALLBACK(SLuaCallBack* p)
{ // the callback function of the new Lua command
simLockInterface(1);
int result=-1; // error
struct SWiiData returnData;
if (p->inputArgCount>0)
{ // Ok, we have at least 1 input argument
if (p->inputArgTypeAndSize[0*2+0]==sim_lua_arg_int)
{ // Ok, we have (at least) 1 int as argument
if ( (p->inputInt[0]>=0)&&(p->inputInt[0]<4)&&(startCountPerDevice[p->inputInt[0]]>0) )
{ // Ok, we have an "open" device here
returnData.buttonStates=_allDeviceData[p->inputInt[0]].buttonStates;
returnData.accelerationX=_allDeviceData[p->inputInt[0]].accelerationX;
returnData.accelerationY=_allDeviceData[p->inputInt[0]].accelerationY;
returnData.accelerationZ=_allDeviceData[p->inputInt[0]].accelerationZ;
returnData.roll=_allDeviceData[p->inputInt[0]].roll;
returnData.pitch=_allDeviceData[p->inputInt[0]].pitch;
returnData.batteryState=_allDeviceData[p->inputInt[0]].batteryState;
result=1;
}
else
simSetLastError(LUA_GET,"Invalid device index."); // output an error
}
else
simSetLastError(LUA_GET,"Wrong argument type/size."); // output an error
}
else
simSetLastError(LUA_GET,"Not enough arguments."); // output an error
// Now we prepare the return value(s):
if (result==-1)
{ // We just return -1 in case of an error
p->outputArgCount=1; // 1 return value
p->outputArgTypeAndSize=(simInt*)simCreateBuffer(p->outputArgCount*2*sizeof(simInt)); // x return values takes x*2 simInt for the type and size buffer
p->outputArgTypeAndSize[2*0+0]=sim_lua_arg_int; // The return value is an int
p->outputArgTypeAndSize[2*0+1]=1; // Not used (table size if the return value was a table)
p->outputInt=(simInt*)simCreateBuffer(1*sizeof(result)); // 1 int return value
p->outputInt[0]=result; // This is the int value we want to return
}
else
{ // We return: result,buttons,acceleration(table_3),orientation(table_2),battery
p->outputArgCount=5; // 5 return values
p->outputArgTypeAndSize=(simInt*)simCreateBuffer(p->outputArgCount*5*sizeof(simInt)); // x return values takes x*2 simInt for the type and size buffer
p->outputArgTypeAndSize[2*0+0]=sim_lua_arg_int; // The return value is an int
p->outputArgTypeAndSize[2*0+1]=1; // Not used (table size if the return value was a table)
p->outputArgTypeAndSize[2*1+0]=sim_lua_arg_int; // The return value is an int
p->outputArgTypeAndSize[2*1+1]=1; // Not used (table size if the return value was a table)
p->outputArgTypeAndSize[2*2+0]=sim_lua_arg_float|sim_lua_arg_table; // The return value is a float table
p->outputArgTypeAndSize[2*2+1]=3; // table size is 3
p->outputArgTypeAndSize[2*3+0]=sim_lua_arg_float|sim_lua_arg_table; // The return value is a float table
p->outputArgTypeAndSize[2*3+1]=2; // table size is 2
p->outputArgTypeAndSize[2*4+0]=sim_lua_arg_int; // The return value is an int
p->outputArgTypeAndSize[2*4+1]=1; // Not used (table size if the return value was a table)
p->outputInt=(simInt*)simCreateBuffer(3*sizeof(int)); // 1+1+1 int return value
p->outputInt[0]=result;
p->outputInt[1]=int(returnData.buttonStates);
p->outputInt[2]=int(returnData.batteryState);
p->outputFloat=(simFloat*)simCreateBuffer(5*sizeof(float)); // 3+2 float return value
p->outputFloat[0]=returnData.accelerationX;
p->outputFloat[1]=returnData.accelerationY;
p->outputFloat[2]=returnData.accelerationZ;
p->outputFloat[3]=returnData.roll*DEGREE_TO_RAD;
p->outputFloat[4]=returnData.pitch*DEGREE_TO_RAD;
}
simLockInterface(0);
}
void LUA_START_CALLBACK(SLuaCallBack* p)
{ // the callback function of the new Lua command
simLockInterface(1);
int deviceIndex=-1; // error
if (p->inputArgCount>0)
{ // Ok, we have at least 1 input argument
if (p->inputArgTypeAndSize[0*2+0]==sim_lua_arg_int)
{ // Ok, we have (at least) 1 int as argument
int effectiveDeviceIndex=-1;
int desiredIndex=p->inputInt[0];
if (desiredIndex==-1)
{ // We want any free device (not yet being used)
// We search for a free slot:
for (int i=0;i<4;i++)
{
if (_allDevices[i]==NULL)
{
desiredIndex=i;
break;
}
}
}
if ( (desiredIndex>=0)&&(desiredIndex<4) )
{
if (_allDevices[desiredIndex]==NULL)
{ // We connect to a new device!
wiimote* it=new wiimote();
it->ChangedCallback=on_state_change;
it->CallbackTriggerFlags=(state_change_flags)(CONNECTED|EXTENSION_CHANGED|MOTIONPLUS_CHANGED);
if (it->Connect(desiredIndex+1))
{ // Success!
_allDeviceData[desiredIndex].buttonStates=0;
_allDeviceData[desiredIndex].batteryState=0;
_allDeviceData[desiredIndex].accelerationX=0.0f;
_allDeviceData[desiredIndex].accelerationY=0.0f;
_allDeviceData[desiredIndex].accelerationZ=0.0f;
_allDeviceData[desiredIndex].pitch=0.0f;
_allDeviceData[desiredIndex].roll=0.0f;
_allDeviceData[desiredIndex].rumble=0;
_allDeviceData[desiredIndex].leds=0;
_allDeviceData[desiredIndex].initialized=false;
_allDevices[desiredIndex]=it;
}
else
desiredIndex=-1; // No more devices available!
}
}
if ( (desiredIndex>=0)&&(desiredIndex<4) )
{
if (startCountOverall==0)
{ // Launch the thread!
_wiiThreadLaunched=false;
CreateThread(NULL,0,_wiiThread,NULL,THREAD_PRIORITY_NORMAL,NULL);
while (!_wiiThreadLaunched)
Sleep(2);
}
startCountOverall++;
startCountPerDevice[desiredIndex]++;
deviceIndex=desiredIndex;
}
else
simSetLastError(LUA_START,"Invalid device index, or no available device at given index. Is device connected?"); // output an error
}
else
simSetLastError(LUA_START,"Wrong argument type/size."); // output an error
}
else
simSetLastError(LUA_START,"Not enough arguments."); // output an error
// Now we prepare the return value:
p->outputArgCount=1; // 1 return value
p->outputArgTypeAndSize=(simInt*)simCreateBuffer(p->outputArgCount*2*sizeof(simInt)); // x return values takes x*2 simInt for the type and size buffer
p->outputArgTypeAndSize[2*0+0]=sim_lua_arg_int; // The return value is an int
p->outputArgTypeAndSize[2*0+1]=1; // Not used (table size if the return value was a table)
p->outputInt=(simInt*)simCreateBuffer(1*sizeof(deviceIndex)); // 1 int return value
p->outputInt[0]=deviceIndex; // This is the int value we want to return
simLockInterface(0);
}
