hello

static LONG stub_RexxSupportPPC(uint32 *regarray)
{
struct Library *Base = (struct Library *) regarray[REG68K_A6/4];
struct ExtendedLibrary *ExtLib = (struct ExtendedLibrary *) ((uint32)Base + Base->lib_PosSize);
struct Microbe3DIFace *Self = (struct Microbe3DIFace *) ExtLib->MainIFace;
struct RexxStuff R;

R.msg=(APTR)regarray[8]; /* arexx msg in a0 */
MyRexxSupport(&R); /* use builtin function */
regarray[8]=regarray[9]=(ULONG)R.argstring; /* arexx argstring in a0 and a1 */
return(R.ret); /* arexx error-code (ret) in d0 */
}
/*=================================================================*/
ULONG rx_DoObjectFx(struct RexxMsg *m)
{
U3D_DoObjectFx((APTR)IA1,(ULONG)IA2);
return(0);
}
/*=================================================================*/
ULONG rx_AddMotionCapture(struct RexxMsg *m)
{
ULONG ret;
ret=(ULONG)U3D_AddMotionCapture((APTR)IA1,(UBYTE*)SA2,(ULONG)IA3,(ULONG)IA4,(float)FA5);
return(ret);
}
/*=================================================================*/
struct arexxfunc rxfuncs[] = {
{"REXXGETFLOAT" ,1,'F',rx_RexxGetFloat},
{"REXXGETNAME" ,1,'S',rx_RexxGetName},
{"REXXSETCOLOR" ,5,'R',rx_RexxSetColor},
{"REXXSETFLOAT" ,2,'R',rx_RexxSetFloat},
{"REXXSETNAME" ,2,'R',rx_RexxSetName},
{"REXXSETVERTEX" ,4,'R',rx_RexxSetVertex},

{"ADDBONE" ,6,'R',rx_AddBone},
{"ADDFACE" ,1,' ',rx_AddFace},
{"ADDGROUP" ,3,'R',rx_AddGroup},
{"ADDINSTANCE" ,3,'R',rx_AddInstance},
{"ADDMAP" ,6,'R',rx_AddMap},
{"ADDMOTIONCAPTURE" ,5,'R',rx_AddMotionCapture},
{"ADDOBJECT" ,4,'R',rx_AddObject},
{"ADDPOINT" ,4,' ',rx_AddPoint},
{"ADDSKIN" ,3,'R',rx_AddSkin},
{"BOX" ,4,' ',rx_Box},
{"DELETE" ,1,' ',rx_Delete},
{"DIMENSIONS" ,4,' ',rx_Dimensions},
{"DOOBJECTFX" ,2,' ',rx_DoObjectFx},
{"DRAWSCENE" ,1,' ',rx_DrawScene},
{"EASYOPENSCENE" ,3,'R',rx_EasyOpenScene},
{"FIND" ,3,'R',rx_Find},
{"GET" ,3,'R',rx_Get},
{"GETTILE" ,4,'R',rx_GetTile},
{"GRIDWELD" ,4,' ',rx_GridWeld},
{"MOTIONCAPTURECUT" ,4,'R',rx_MotionCaptureCut},
{"MOTIONCAPTUREJOIN" ,4,'R',rx_MotionCaptureJoin},
{"MOTIONCAPTUREFX" ,5,'R',rx_MotionCaptureFx},
{"NAME" ,1,'R',rx_Name},
{"NORMALS" ,2,' ',rx_Normals},
{"OPENSCENE" ,7,'R',rx_OpenScene},
{"QUERYVALUE" ,2,'R',rx_QueryValue},
{"READ" ,2,'R',rx_Read},
{"REVERSEWINDING" ,1,' ',rx_ReverseWinding},
{"ROTATE" ,5,' ',rx_Rotate},
{"SCALE" ,5,' ',rx_Scale},
{"SETAMPLITUDE" ,7,' ',rx_SetAmplitude},
{"SETBONEEQUIVALENCE" ,3,' ',rx_SetBoneEquivalence},
{"SETBONEINFLUENCE" ,4,' ',rx_SetBoneInfluence},
{"SETINSTANCE" ,3,' ',rx_SetInstance},
{"SETLIGHT" ,3,' ',rx_SetLight},
{"SETLIGHTPLUS" ,6,' ',rx_SetLightPlus},
{"SETMOTIONCAPTURE" ,3,' ',rx_SetMotionCapture},
{"SETSPECIALMATERIAL" ,4,' ',rx_SetSpecialMaterial},
{"SETTILE" ,5,' ',rx_SetTile},
{"SETTILEDEF" ,3,' ',rx_SetTileDef},
{"SETVALUE" ,3,' ',rx_SetValue},
{"SWAPAXIS" ,2,' ',rx_SwapAxis},
{"TRANSLATE" ,5,' ',rx_Translate},
{"UNITIZE" ,2,' ',rx_Unitize},
{"WELD" ,4,' ',rx_Weld},
{"WRITE" ,2,' ',rx_Write},
};
#define FUNCCOUNT (sizeof(rxfuncs)/sizeof(struct arexxfunc))
/*=================================================================*/
APTR findrxfunc(UBYTE *name)
{
ULONG n;

name=&name[4]; /* skip U3D_ */
NLOOP(FUNCCOUNT)
if(IsKeyword(rxfuncs[n].name,name))
return(&rxfuncs[n]);

return(NULL);
}
/*=================================================================*/
void MyRexxSupport(struct RexxStuff *R)
{
struct RexxMsg *m=R->msg;
struct arexxfunc *rxfunc;
UBYTE argscount;
char name[256];
ULONG n;
float *F;
struct Task *mytask;
ULONG mystack;

REM(RexxSupport)

mytask=FindTask(NULL);
mystack=((ULONG)mytask->tc_SPUpper) - ((ULONG)mytask->tc_SPLower);
if(mystack < MICROBE3DSTACK)
{
errorprintf("Error: Rexx/Stack too low %ld !!\n",mystack);
R->ret=ERR10_003; /* no memory available */
R->argstring= NULL;
((struct RxsLib*)RexxSysBase)->rl_StackSize=MICROBE3DSTACK;
return;
}

if(rexxdebug) Libprintf("RexxSupport=======================\n");
argscount = m->rm_Action & RXARGMASK;
if(rexxdebug) Libprintf("Func: %s\n",m->rm_Args[0]);
rxfunc = findrxfunc(RXARG0);

NLOOP(argscount)
{
if(rexxdebug) Libprintf("Arg%ld: <%s>\n",n+1,m->rm_Args[n+1]);
}

if (rxfunc == NULL)
{
if(rexxdebug) Libprintf("Unknown function%s !!\n",RXARG0);
R->ret=ERR10_015; /* function not found */
R->argstring= NULL;
return;
}

if (argscount != rxfunc->argscount)
{
if(rexxdebug) Libprintf("Function %s need %ld args !!\n",RXARG0,rxfunc->argscount);
R->ret=ERR10_017; /* wrong number of arguments */
R->argstring= NULL;
return;
}

if(rexxdebug==2) OSAlert("Ready?");

R->ret = rxfunc->func(m); /* call the function */
R->argstring = NULL;

if(rexxdebug) Libprintf("Function %s()\n",RXARG0);
if(rxfunc->returntype==' ') /* no return value */
{
if(rexxdebug) Libprintf("return: nothing \n");
Libsprintf(name,"0");
}

if(rxfunc->returntype=='R') /* got a return value */
{
if(rexxdebug) Libprintf("return: int \n");
Libsprintf(name,"%ld",R->ret);
}

if(rxfunc->returntype=='S') /* STRING return value */
{
if(rexxdebug) Libprintf("return: string \n");
Libsprintf(name,"%s",(UBYTE*)R->ret);
}

if(rxfunc->returntype=='F') /* float return value */
{
if(rexxdebug) Libprintf("return: float \n");
F=(float*)&R->ret; /* float encoded as LONG */
spf(name,F[0]);
}

R->ret=RC_OK;
R->argstring=CreateArgstring(name,Libstrlen(name));

if(rexxdebug) Libprintf("ret: %ld argstring: <%s>\n",R->ret,R->argstring);
if(rexxdebug) Libprintf("----------------------------------\n");
if(rexxdebug==2) OSAlert("Done");

}