dreyndev/JD2022-TU1
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
JD2022-TU1/main/extern/Camcam/LIBS/Mixer/Command2.h

4419 lines
134 KiB
C
Raw Blame History

DEFINE_SCRIPT_REN(SCN_IKCompute, ComputeIK,
CATEGORY(Small Scene) PARAM_SCENE(Smsc) PARAM_INT(IKNumber) ,
"If available, compute IK in the scene. You can compute IK for several different render<br/> Indicate it in the [instance].<br/>",
{
ComputeSmallSceneIK(Smsc,IKNumber);
})
DEFINE_SCRIPT(TRK_StatusColorGet,
CATEGORY(Tracking) PARAM_INT_OPT(TrackeurID, 0),
"Get mesh status color",
{
int status;
if (TrackeurID >= MAX_ID) TrackeurID = MAX_ID-1;
if (TrackeurID < 0) TrackeurID= 0;
if (ID_TABLE[TrackeurID])
{
RETURN_COLOR(ID_TABLE[TrackeurID]->StatusMeshColor);
} else
{
RETURN_COLOR(0);
}
})
DEFINE_SCRIPT(TRK_ForceTracking,
CATEGORY(Media AVI) PARAM_INT_OPT(set, 1),
"Stock the Avi file into image file",
{
ForceTraking = set;
})
DEFINE_SCRIPT(TRK_CameraGetFPS, CATEGORY(Tracking) ,"Get FPS of media tracking source",
{
RETURN_INT((u32)(1000.0 / (double)(trackMiliseconds_x_16>>8)));
})
DEFINE_SCRIPT_REN(TRK_IDScaleSet, IDSetScale,
CATEGORY(Tracking) PARAM_INT(IDNum) PARAM_VECTOR(NewScale),
"Set the scale of the tracking mask",
{
ID_SetScale(IDNum , &NewScale);
})
DEFINE_SCRIPT_REN(TRK_IDAutodetectParamsSet, IDSetAutodetectParams,
CATEGORY(Tracking) PARAM_INT(IDNum) PARAM_FLOAT(ZoomFactor) PARAM_FLOAT(VerticalFactor) PARAM_FLOAT(RotationAngle),
"Set better match auto-detect parrams",
{
Vector datas;
datas.x = ZoomFactor;
datas.y = VerticalFactor;
datas.z = RotationAngle;
ID_SetHaarParrams(IDNum , &datas);
})
DEFINE_SCRIPT(TRK_IDNew,
CATEGORY(Tracking) PARAM_INT(IDNum),
"Create New ID",
{
ID_New(IDNum);
})
DEFINE_SCRIPT(CAMERA_SetRes,
CATEGORY(CAMERA) PARAM_INT_OPT(Witdh,320),
"Change default resolution of camera. Use this before create media camera. Default is 320",
{
if (Witdh < 320) Witdh = 320;
extern int CAMERA_SpecifyedW;
CAMERA_SpecifyedW = Witdh;
})
DEFINE_SCRIPT(CAMERA_List,
CATEGORY(CAMERA) PARAM_INT_OPT(refresh, 0),
"Get table of available camera<br/>Warning, if only one camera is avilable, return camera name (no table)",
{
extern char WebCamNames[64][256];
extern int NbWebCams;
if (refresh)
{
int GetWebCamNames(char compressors[][256], int *nbCompressors, int maxCompressors);
GetWebCamNames(WebCamNames, &NbWebCams, 64);
}
for (int camIdx=0; camIdx<NbWebCams; camIdx++)
{
RETURN_STRING(WebCamNames[camIdx]);
}
})
DEFINE_SCRIPT(CAMERA_Set,
CATEGORY(CAMERA) PARAM_STRING(camera),
"Set default camera<br/>if default camera changed, return true, else return false",
{
extern TCHAR CurrWebCam[256];
if (strcmp(camera, CurrWebCam))
{
strcpy(CurrWebCam, camera);
SetIniValue(CamcamCCM, "CurrWebCam", camera);
SaveIniFile(CamcamCCM);
u32 MediaIndex;
if (GetMediaFromString("CAM1", &MediaIndex))
{
int nbRef = 0;
for (;ID_MEDIA[MediaIndex];nbRef++)
DestroyMedia(MediaIndex);
for (int i=0; i<nbRef; i++)
CreateMedia("CAM1",0);
}
RETURN_BOOL(1);
} else
{
RETURN_BOOL(0);
}
})
DEFINE_SCRIPT(CAMERA_Get,
CATEGORY(CAMERA),
"Return current camera",
{
extern TCHAR CurrWebCam[256];
if (*CurrWebCam)
{ RETURN_STRING(CurrWebCam); }
})
DEFINE_SCRIPT(CAMERA_ProperyOpen,
CATEGORY(CAMERA) PARAM_STRING_OPT(camera, ""),
"Open property calmera page",
{
extern TCHAR CurrWebCam[256];
BOOL GetWebCamFilterPropertyByName(char *name, bool openPage);
if (*camera)
{
GetWebCamFilterPropertyByName(camera, true);
} else
{
GetWebCamFilterPropertyByName(CurrWebCam, true);
}
})
DEFINE_SCRIPT(TRK_IDRemove,
CATEGORY(Tracking) PARAM_INT(IDNum),
"Remove an ID from camcam (do not delete the file)",
{
/* TEST NOT HERE NORMALY */
if (ID_TABLE[IDNum])
{
ID_Destroy(IDNum);
}
})DEFINE_SCRIPT_REN(TRK_IDLoad, IDLoad,
CATEGORY(Tracking) PARAM_INT(IDNum) PARAM_STRING(IDName),
"Load an ID",
{
char IDNameDir[2048];
if (IDName[0] && IDName[1] == ':')
{
sprintf(IDNameDir, "%s", IDName);
for (int i=0; IDNameDir[i] != '\0'; ++i)
if(IDNameDir[i] == '/')
IDNameDir[i] = '\\';
}
else sprintf(IDNameDir,".\\Ids\\%s",IDName);
ID_Load(IDNum,IDNameDir);
})
DEFINE_SCRIPT_REN(TRK_IDSave, IDSave,
CATEGORY(Tracking) PARAM_INT(IDNum) PARAM_STRING(IDName),
"Save an ID",
{
char IDNameDir[2048];
if (IDName[0] && IDName[1] == ':')
{
sprintf(IDNameDir, "%s", IDName);
for (int i=0; IDNameDir[i] != '\0'; ++i)
if(IDNameDir[i] == '/')
IDNameDir[i] = '\\';
}
else sprintf(IDNameDir,".\\Ids\\%s",IDName);
ID_Save(IDNum,IDNameDir);
})
DEFINE_SCRIPT(TRK_IDDel,
CATEGORY(Tracking) PARAM_STRING(IDName),
"Del an ID",
{
char IDNameDir[2048];
if (IDName[0] && IDName[1] == ':')
{
sprintf(IDNameDir, "%s", IDName);
for (int i=0; IDNameDir[i] != '\0'; ++i)
if(IDNameDir[i] == '/')
IDNameDir[i] = '\\';
}
else sprintf(IDNameDir,".\\Ids\\%s",IDName);
DeleteFile(IDNameDir);
})
DEFINE_SCRIPT_REN(TRK_IDCurrentGet, IDGetCurrent,
CATEGORY(Tracking),
"Return the current ID used",
{
RETURN_INT( CurrentID);
})
DEFINE_SCRIPT_REN(TRK_IDCurrentSet, IDSetCurrent,
CATEGORY(Tracking) PARAM_INT(IDNum),
"Set the current ID<br/>The function returns the true new ID",
{
if (IDNum < NumberOfID)
{
CurrentID = IDNum;
} else
{
CurrentID = ID_New();
}
RETURN_INT( CurrentID);
})
DEFINE_SCRIPT(TRK_IDMeshLoad,
CATEGORY(Tracking) PARAM_INT(IDNum) PARAM_STRING(MeshName),
"Load an mesh object for ID",
{
FILE *F;
char path[2048];
if (IDNum >= NumberOfID)
{
ID_New(IDNum);
}
sprintf(path, ".\\%s", MeshName);
F = fopen(path,"rt");
if (!F)
{
sprintf(path, ".\\%s.obj", MeshName);
F = fopen(path,"rt");
}
if (F)
{
extern u32 LoadObj(Mesh *LoadMesh,FILE *F);
if (VALIDATE_ID(IDNum))
{
Mesh MyMesh;
LoadObj(&MyMesh,F);
MyMesh.ulNumberOfSubObjects = 1;
MyMesh.FaceSubObjectIndexes[0] = MyMesh.NumberOfFaces;
MyMesh.FaceSubObjectIndexes[1] = 0;
MyMesh.BVIfy();
ID_SetMesh(IDNum, &MyMesh);
//ID_TABLE[IDNum]->p_UsedMesh = CopyMesh(&MyMesh);
//LoadObj(ID_TABLE[IDNum]->p_UsedMesh, F);
} else
fclose(F);
}
})
DEFINE_SCRIPT_REN(SCN_CameraCopy, CopyCamera,
CATEGORY(Small Scene) PARAM_SCENE(DestSmsc) PARAM_SCENE(SourceSmsc),
"copy camera(CP) from SOURCE to DEST",
{
DestSmsc->CameraPosition = SourceSmsc->CameraPosition;
})
#ifndef SKIMMED_NET
DEFINE_SCRIPT_REN(NET_PortSet, SetNetPort,
CATEGORY(Network) PARAM_INT(Port),
"return 0 if can't open port",
{
RETURN_INT( NetObj->SetNetPort(Port));
})
#endif
DEFINE_SCRIPT_REN(DRW_Text, DrawText,
CATEGORY(Drawing) PARAM_INT(X) PARAM_INT(Y) PARAM_COLOR(color) PARAM_STRING(StringToWrite),
"draw the text in current viewport",
{
if (!(SkipFunctions & SKIP_DRAWING))
{
color = ARGB2ABGR(color);
DI->DrawText((unsigned char *)StringToWrite,(float)X,(float)Y,1.0f,1.0f, color);
}
})
DEFINE_SCRIPT_REN(DRW_TextCenter, DrawTextCenter,
CATEGORY(Drawing) PARAM_COLOR(color) PARAM_STRING(StringToWrite),
"draw the text in current viewport",
{
if (!(SkipFunctions & SKIP_DRAWING))
{
color = ARGB2ABGR(color);
DI->DrawTextCentered((unsigned char *)StringToWrite, color);
}
})
DEFINE_SCRIPT_REN(DRW_FontText, RenderText,
CATEGORY(Drawing) PARAM_INT(X) PARAM_INT(Y) PARAM_COLOR(color) PARAM_STRING(FontName) PARAM_STRING(StringToWrite) PARAM_INT_OPT(BlendingMode, -1) PARAM_FLOAT_OPT(scale, 1.0),
"draw the text in current viewport with specified font<br/>Font is a media specified by [FontName Size Mode FONT]<br/>Mode is a mix of the options:<br/>B: Bold - I: Italic - U: Underline<br/>A: Antialiased - C: Contour - T: Transparency ",
{
if (!(SkipFunctions & SKIP_DRAWING))
{
color = ARGB2ABGR(color);
RenderText((unsigned char *)StringToWrite,(float)X,(float)Y,scale,scale, color, FontName, BlendingMode);
}
})
DEFINE_SCRIPT(DRW_Line,
CATEGORY(Drawing) PARAM_INT(X1) PARAM_INT(Y1) PARAM_INT(X2) PARAM_INT(Y2) PARAM_COLOR(color) PARAM_INT_OPT(Lenght, 0),
"Draw a line between (X1,Y1) and (X2,Y2)",
{
Vector A(X1,Y1,0);
Vector B(X2,Y2,0);
color = ARGB2ABGR(color);
if (!(SkipFunctions & SKIP_DRAWING))
DI->Draw2DLine(color, &A, &B, Lenght);
})
DEFINE_SCRIPT(DRW_Line3D,
CATEGORY(Drawing) PARAM_SCENE(SmSc) PARAM_VECTOR(P1) PARAM_VECTOR(P2) PARAM_COLOR(color) PARAM_INT_OPT(Lenght, 0) PARAM_INT_OPT(ZTest, 1),
"Draw a line between P1 and P2 in scene world",
{
if (!(SkipFunctions & SKIP_DRAWING))
{
float Current_focale;
if (SmSc->fFocalToUseForNextRender == 0)
Current_focale = GetCurrentFocale();
else
Current_focale = SmSc->fFocalToUseForNextRender;
if (SmSc->HoloGraphicWindowWidth)
DI->Holographic(&SmSc->HoloGraphicVector,SmSc->HoloGraphicWindowWidth);
else
DI->Perspective(Current_focale);
MATRIX CP;
MATRIX MatrixToSet;
MATRIX WM;
RS LineRS;
GLOB_SetDefaultRS(&LineRS);
if (!ZTest)
LineRS.NOZTEST = 1;
LineRS.BlendingMode = 1;
DI->SetRS(&LineRS, -1);
CP = SmSc->CameraPosition;
CP.K *= -1.0f;
CP.Inverse(MatrixToSet);
WM = SmSc->RootMatrix;
WM *= MatrixToSet;
DI->Matrix(&WM);
color = ARGB2ABGR(color);
DI->DrawLine(color, &P1, &P2, Lenght);
}
})
DEFINE_SCRIPT(DRW_Triangle,
CATEGORY(Drawing) PARAM_VECTOR(P1) PARAM_VECTOR(P2) PARAM_VECTOR(P3) PARAM_VECTOR_OPT(UV1, Vector(0,0,0)) PARAM_VECTOR_OPT(UV2, Vector(1,0,0)) PARAM_VECTOR_OPT(UV3, Vector(1,1,0)) PARAM_MEDIA(Mi) PARAM_INT_OPT(BlendMode,0),
"Draw triangle with the specified uv",
{
if (!(SkipFunctions & SKIP_DRAWING))
{
RenderTriangle(NULL, Mi, &P1,&P2,&P3,&UV1,&UV2,&UV3, BlendMode);
}
})
DEFINE_SCRIPT(DRW_Triangle3D,
CATEGORY(Drawing) PARAM_SCENE(SmSc) PARAM_VECTOR(P1) PARAM_VECTOR(P2) PARAM_VECTOR(P3) PARAM_VECTOR_OPT(UV1, Vector(0,0,0)) PARAM_VECTOR_OPT(UV2, Vector(1,0,0)) PARAM_VECTOR_OPT(UV3, Vector(1,1,0)) PARAM_MEDIA(Mi) PARAM_INT_OPT(BlendMode,0),
"Draw triangle with the specified uv",
{
if (!(SkipFunctions & SKIP_DRAWING))
{
RenderTriangle(SmSc, Mi, &P1,&P2,&P3,&UV1,&UV2,&UV3, BlendMode);
}
})
DEFINE_SCRIPT_REN(SCN_Load, LoadSmSc,
CATEGORY(Small Scene) PARAM_STRING(SceneName),
"load 3D",
{
UnicID SmScID = SmallSceneDico.IsExist(SceneName);
if (SmScID == -1)
{
if (LoadSmSc(SceneName) == -1)
{
//sprintf(LuaErrors, "Scene %s not Found", SceneName);
RETURN_BOOL(0);
} else
{
RETURN_BOOL(1);
}
} else
{
// Recreate Media if (virtualy destroyed)
SmallScene *SmSc;
SmSc = pSmallScenes[SmallSceneDico.mpst_Dico[SmScID].AssociatedValue];
ReLoadSmSc(SmSc);
RETURN_BOOL(1);
}
})
DEFINE_SCRIPT(SCN_Delete,
CATEGORY(Small Scene) PARAM_STRING(SceneName),
"delete 3D",
{
DeleteSmSc(SceneName);
})
DEFINE_SCRIPT(SCN_LinkObjectToVertex,
CATEGORY(Small Scene) PARAM_SCENE(Smsc) PARAM_INT(index) PARAM_STRING(DummyObject) PARAM_STRING(SceneObject) PARAM_INT_OPT(Force, 0),
"Affect Dummy object to vertex in Scene Object",
{
RETURN_BOOL(AffectObjectToVertex(Smsc, index, DummyObject, SceneObject, Force));
})
DEFINE_SCRIPT(SCN_LinkObjectSnap,
CATEGORY(Small Scene) PARAM_SCENE(Smsc) PARAM_STRING(DummySnapSrc) PARAM_STRING(DummySnapDst),
"Link snap dummy to dummy",
{
RETURN_BOOL(ObjectLinkSnap(Smsc, DummySnapSrc, DummySnapDst));
})
DEFINE_SCRIPT(SCN_LinkObjectScale,
CATEGORY(Small Scene) PARAM_SCENE(Smsc) PARAM_STRING(DummySnapSrc1) PARAM_STRING(DummySrc2) PARAM_STRING(DummySnapDst1) PARAM_STRING(DummyDst2) PARAM_INT(axe) PARAM_INT_OPT(mode, 0),
"link snap dummy to dummy adding scale factor <br/> Scale depends on used axes",
{
RETURN_BOOL(ObjectLinkScale(Smsc, DummySnapSrc1, DummySrc2, DummySnapDst1, DummyDst2, axe, mode));
})
DEFINE_SCRIPT(SCN_LinkScaleVectorGet,
CATEGORY(Small Scene) PARAM_MATRIX(SrcMatrix) PARAM_VECTOR(SrcDummy) PARAM_MATRIX(DstMatrix) PARAM_VECTOR(DstDummy) PARAM_INT(axe) PARAM_INT_OPT(mode, 0),
"link snap dummy to dummy adding scale factor <br/> Scale depends on used axes",
{
Vector scaleVect = GetScaleVector(&SrcMatrix, &SrcDummy, &DstMatrix, &DstDummy, axe, mode);
RETURN_VECTOR(&scaleVect);
})
DEFINE_SCRIPT_REN(SCN_Render, Render,
CATEGORY(Small Scene) PARAM_STRING(SmallSceneName),
"Render smallscene",
{
START_RASTER(Rendering);
if (!(SkipFunctions & SKIP_RENDER))
{ RETURN_BOOL(RenderSmallScene(SmallSceneName)); }
else
{ RETURN_BOOL(true); }
STOP_RASTER(Rendering);
})
DEFINE_SCRIPT(SCN_RenderIK,
CATEGORY(Small Scene) PARAM_SCENE(SmallScene),
"Render smallscene",
{
START_RASTER(Rendering);
if (!(SkipFunctions & SKIP_RENDER))
DrawSmallSceneIK(SmallScene);
STOP_RASTER(Rendering);
})
DEFINE_SCRIPT(SCN_ReverseRender,
CATEGORY(Small Scene) PARAM_STRING(SmallSceneName) PARAM_FLOAT_OPT(ComputeAlpha,0.0),
"Reverse Render smallscene, ComputeAlpha mean compute alpha according to normale incidence to camera. 0 Will comupte alpha = 1",
{
START_RASTER(Rendering);
if (!(SkipFunctions & SKIP_RENDER))
{
DI->ComputeMaskAlpha = ComputeAlpha;
ReverseRenderSmallScene(SmallSceneName);
DI->ComputeMaskAlpha = 0.0;
}
STOP_RASTER(Rendering);
})
DEFINE_SCRIPT_REN(SCN_MatrixReset, ResetMatrix,
CATEGORY(Small Scene) PARAM_AFFECT(Affect) PARAM_SCENE(Smsc),
"[.T] = Translation<br/> [.R] = Rotation<br/> [.TR] or nothing = Rotation + translation<br/>restor small scene initial position",
{
if (Affect & 1)
{
Smsc->RootMatrix.T = Vector(0,0,0);
}
if (Affect & 2)
{
Smsc->RootMatrix.I = Vector(1,0,0);
Smsc->RootMatrix.J = Vector(0,1,0);
Smsc->RootMatrix.K = Vector(0,0,1);
}
ComputeSmallSceneHierarchie(Smsc);
})
DEFINE_SCRIPT(SCN_RootMatrixGet,
CATEGORY(Small Scene) PARAM_SCENE(Smsc),
"Get Root Matrix",
{
RETURN_MATRIX(&Smsc->RootMatrix);
})
DEFINE_SCRIPT(SCN_RootMatrixSet,
CATEGORY(Small Scene) PARAM_SCENE(Smsc) PARAM_MATRIX(Mat),
"Set Root Matrix",
{
Smsc->RootMatrix = Mat;
ComputeSmallSceneHierarchie(Smsc);
})
DEFINE_SCRIPT(SCN_MatrixSet,
CATEGORY(Small Scene) PARAM_AFFECT(Affect) PARAM_SCENE(SmSc) PARAM_MATRIX(matrix) PARAM_FLOAT_OPT(Focale, 0),
"Affect a track matrix to a scene <br/>[.TR] mean:<br/> [.T] = Translation<br/> [.R] = Rotation<br/> [.S] = Mask scale<br/> [.TR] or nothing = Rotation + translation",
{
Vector matrixScale;
matrixScale.x = matrix.I.Norm(); matrix.I.Normalize();
matrixScale.z = matrix.J.Norm(); matrix.J.Normalize();
matrixScale.y = matrix.K.Norm(); matrix.K.Normalize();
AffectTrackMatrixToSmallScene(0, SmSc,Affect,&matrix);
if (Affect & 256)
{
AffectTrackScaleToSmallScene(SmSc,&matrixScale);
}
if (Focale == 0)
SmSc->fFocalToUseForNextRender = ID_MEDIA[MediaToTrack]->MediaFocale;//*/
else
SmSc->fFocalToUseForNextRender = Focale;
})
DEFINE_SCRIPT(SNC_SubMatrixSet,
CATEGORY(Tracking) PARAM_AFFECT(Affect) PARAM_SCENE(SmSc) PARAM_STRING(ObjectName) PARAM_MATRIX(matrix) PARAM_INT_OPT(AxeModifier, 0),
"Affect trackeur matrix to an object of a small scene<br/>[.TR] mean:<br/> [.T] = Translation<br/> [.R] = Rotation<br/> [.S] = Mask scale<br/> [Index] object number - Warning begin at 1 !!<br/> [.TR] or nothing = Rotation + translation",
{
AffectTrackSubMatrixToSmallScene(0, SmSc,ObjectName,Affect,&matrix, AxeModifier);
})
DEFINE_SCRIPT_REN(SCN_MediaMatrixSet, MediaSetMatrix,
CATEGORY(Small Scene) PARAM_SCENE(SmSc) PARAM_MEDIA(Mi) PARAM_INT(TrackNum) PARAM_INT_OPT(maxStatus, 0) PARAM_INT_OPT(useTimeLineCorrection, 0),
"Medianame is used for finding current frame number<br/>Max Status sets allowed track status",
{
RETURN_INT(MediaSetMatrix(SmSc,Mi,TrackNum, maxStatus, useTimeLineCorrection));
})
DEFINE_SCRIPT_REN(TRK_MatrixSet, SetTrackMatrix,
CATEGORY(Tracking) PARAM_AFFECT(Affect) PARAM_INT(TrackeurID) PARAM_SCENE(SmSc) PARAM_INT_OPT(SmoothModeNumber, 0),
"Affect trackeur matrix to a small scene<br/>[.TR] mean:<br/> [.T] = Translation<br/> [.R] = Rotation<br/> [.S] = Mask scale<br/> [.TR] or nothing = Rotation + translation",
{
MATRIX smoothMatrix;
if (TrackeurID >= MAX_ID) TrackeurID = MAX_ID-1;
if (TrackeurID < 0) TrackeurID = 0;
if (ID_TABLE[TrackeurID])
{
smoothMatrix = ID_TABLE[TrackeurID]->CurrentMatrix_U;
AffectTrackMatrixToSmallScene(SmoothModeNumber, SmSc,Affect,&smoothMatrix);
if (Affect & 256)
AffectTrackScaleToSmallScene(SmSc,&ID_TABLE[TrackeurID]->vModelScale);
if (ID_TABLE[TrackeurID]->SF_U.IsAnimatedTrack && (ID_TABLE[TrackeurID]->AnimatedMedia != -1))
SmSc->fFocalToUseForNextRender = ID_MEDIA[ID_TABLE[TrackeurID]->AnimatedMedia]->MediaFocale;
else
SmSc->fFocalToUseForNextRender = ID_MEDIA[MediaToTrack]->MediaFocale;//*/
};
})
DEFINE_SCRIPT(TRK_SubMatrixSet,
CATEGORY(Tracking) PARAM_AFFECT(Affect) PARAM_INT(TrackeurID) PARAM_SCENE(SmSc) PARAM_STRING(ObjectName) PARAM_INT_OPT(AxeModifier, 0) PARAM_INT_OPT(SmoothModeNumber, 0),
"Affect trackeur matrix to an object of a small scene<br/>[.TR] mean:<br/> [.T] = Translation<br/> [.R] = Rotation<br/> [.S] = Mask scale<br/> [Index] object number - Warning begin at 1 !!<br/> [.TR] or nothing = Rotation + translation",
{
MATRIX smoothMatrix;
if (TrackeurID >= MAX_ID) TrackeurID = MAX_ID-1;
if (TrackeurID < 0) TrackeurID = 0;
if (ID_TABLE[TrackeurID])
{
smoothMatrix = ID_TABLE[TrackeurID]->CurrentMatrix_U;
AffectTrackSubMatrixToSmallScene(SmoothModeNumber, SmSc,ObjectName,Affect,&smoothMatrix, AxeModifier);
if (ID_TABLE[TrackeurID]->SF_U.IsAnimatedTrack && (ID_TABLE[TrackeurID]->AnimatedMedia != -1))
SmSc->fFocalToUseForNextRender = ID_MEDIA[ID_TABLE[TrackeurID]->AnimatedMedia]->MediaFocale;
else
SmSc->fFocalToUseForNextRender = ID_MEDIA[MediaToTrack]->MediaFocale;//*/
};
})
DEFINE_SCRIPT(TRK_MatrixChange,
CATEGORY(Tracking) PARAM_INT(TrackeurID) PARAM_MATRIX(matrix),
"Set the tracker matrix<br/>[.TR] mean:<br/> [.T] = Translation<br/> [.R] = Rotation<br/> [.S] = Mask scale<br/> [.TR] or nothing = Rotation + translation",
{
if (TrackeurID >= MAX_ID) TrackeurID = MAX_ID-1;
if (TrackeurID < 0) TrackeurID = 0;
if (ID_TABLE[TrackeurID])
{
Vector matrixScale;
matrixScale.x = matrix.I.Norm(); matrix.I.Normalize();
matrixScale.z = matrix.J.Norm(); matrix.J.Normalize();
matrixScale.y = matrix.K.Norm(); matrix.K.Normalize();
ID_TABLE[TrackeurID]->CurrentMatrix_U = matrix;
ID_SetScale(TrackeurID,&matrixScale);
}
})
DEFINE_SCRIPT_REN(TRK_MatrixGet, GetTrackMatrix,
CATEGORY(Tracking) PARAM_AFFECT(Affect) PARAM_INT(TrackeurID) PARAM_INT_OPT(SmoothNumber, 0) PARAM_INT_OPT(AxeInversion, 0) ,
"return trackeur matrix<br/>[.TR] mean:<br/> [.T] = Translation<br/> [.R] = Rotation<br/> [.TR] or nothing = Rotation + translation",
{
MATRIX smoothMatrix;
Vector scaleVector;
if (TrackeurID >= MAX_ID) TrackeurID = MAX_ID-1;
if (TrackeurID < 0) TrackeurID = 0;
if (ID_TABLE[TrackeurID])
{
smoothMatrix = ID_TABLE[TrackeurID]->CurrentMatrix_U;
SetSmoothMatrix(SmoothNumber, &smoothMatrix, Affect, AxeInversion);
if (Affect & 256)
{
smoothMatrix.I *= ID_TABLE[TrackeurID]->vModelScale.x;
smoothMatrix.J *= ID_TABLE[TrackeurID]->vModelScale.z;
smoothMatrix.K *= ID_TABLE[TrackeurID]->vModelScale.y;
}
switch (Affect)
{
case 1: RETURN_VECTOR(&smoothMatrix.T);break;
case 4: RETURN_VECTOR(&smoothMatrix.I);break;
case 8: RETURN_VECTOR(&smoothMatrix.J);break;
case 16: RETURN_VECTOR(&smoothMatrix.K);break;
case 256: RETURN_VECTOR(&ID_TABLE[TrackeurID]->vModelScale);break;
case 258:
case 2: memset(&smoothMatrix.T, 0, sizeof(smoothMatrix.T));
case 0:
case 259:
case 3: RETURN_MATRIX(&smoothMatrix);break;
case 257: {
MATRIX ts;
ts.I *= ID_TABLE[TrackeurID]->vModelScale.x;
ts.J *= ID_TABLE[TrackeurID]->vModelScale.y;
ts.K *= ID_TABLE[TrackeurID]->vModelScale.z;
ts.T = smoothMatrix.T;
RETURN_MATRIX(&ts);
break;
}
}
}
})
DEFINE_SCRIPT(TRK_BOOT,
CATEGORY(Tracking) PARAM_INT(TrackeurID) PARAM_INT(ON_OFF),
"Use for script Manual Boot, 1-> Begin, 0->End",
{
if (ON_OFF)
{
ID_Reset(TrackeurID);
ID_TABLE[TrackeurID]->SF_U.CamPlaced = 0;
ID_TABLE[TrackeurID]->CurrentMatrix_U.T.z = 90.0f;
ID_TABLE[TrackeurID]->SF_U.FromScratch = 0;
} else
{
ID_TABLE[TrackeurID]->SF_U.Booted = 1;
ID_TABLE[TrackeurID]->SF_U.Ready2Learn = 1;
}
})
DEFINE_SCRIPT_REN(TRK_IDCreateFromMedia, CreateIDFromMedia,
CATEGORY(Tracking) PARAM_INT(ID) PARAM_INT(TrackNum) PARAM_MEDIA(Mi),
"Affect an animated matrix from a media to a new ID",
{
if (ID != 0)
{
ID_NewAnimated(ID,Mi,TrackNum);
Vector Scale;
Scale = Vector(1,1,1);
if (ID_MEDIA[Mi]->Tracks) ID_MEDIA[Mi]->Tracks->GetScale(TrackNum,&Scale);
ID_SetScale(ID,&Scale);
}
})
DEFINE_SCRIPT_REN(DRW_Quad, DRW_QuadBlend,
CATEGORY(Drawing) PARAM_INT(X) PARAM_INT(Y) PARAM_INT(SizeX) PARAM_INT(SizeY) PARAM_MEDIA(Mi) PARAM_INT_OPT(BlendMode,0) ,
"!Medianame must be inside '&lt;' and '&gt;'<br/>BLENDING MODES: 0=COPY;1=ALPHA;2=ADD;3=ALPHA PREMULT;4=PREVIOUS ALPHA;5=Multiply",
{
if (!(SkipFunctions & SKIP_DRAWING))
{
RS LocalRS;
GLOB_SetDefaultRS(&LocalRS);
LocalRS.BlendingMode = BlendMode;
LocalRS.BACKFACE = 0;
DI->DrawQuad(ID_MEDIA[Mi]->ulAssociatedTextureIndex,X,X+SizeX,Y,Y+SizeY,&LocalRS);
}
})
DEFINE_SCRIPT(DRW_QuadDistord,
CATEGORY(Drawing) PARAM_INT(X) PARAM_INT(Y) PARAM_INT(SizeX) PARAM_INT(SizeY) PARAM_MEDIA(Mi) PARAM_INT_OPT(Blend,0),
"!Medianame must be inside '&lt;' and '&gt;' ; Same as DrawQuad, but no ratio correction. Optional parram specify blendingmode",
{
RS LocalRS;
GLOB_SetDefaultRS(&LocalRS);
LocalRS.BlendingMode = Blend;
LocalRS.BACKFACE = 0;
if (!(SkipFunctions & SKIP_DRAWING))
DI->DrawQuadDistord(ID_MEDIA[Mi]->ulAssociatedTextureIndex,X,X+SizeX,Y,Y+SizeY,&LocalRS);
})
DEFINE_SCRIPT(DRW_Circle,
CATEGORY(Drawing) PARAM_FLOAT(X) PARAM_FLOAT(Y) PARAM_FLOAT(InnerRadius) PARAM_FLOAT(OuterRadius) PARAM_FLOAT(ClockDegreeStart) PARAM_FLOAT(ClockDegreeEnd) PARAM_MEDIA(Mi) PARAM_INT_OPT(Blend,0),
"Same as DrawQuadDistord, Read carefully the parrameters",
{
RS LocalRS;
GLOB_SetDefaultRS(&LocalRS);
LocalRS.BlendingMode = Blend;
LocalRS.BACKFACE = 0;
Vector Center = Vector(X,Y,0);
if (!(SkipFunctions & SKIP_DRAWING))
DI->DrawCircle(ID_MEDIA[Mi]->ulAssociatedTextureIndex,&Center,InnerRadius,OuterRadius,ClockDegreeStart,ClockDegreeEnd,&LocalRS);
})
DEFINE_SCRIPT(DRW_Patch32,
CATEGORY(Drawing) PARAM_LIST_VECTOR(pCurves) PARAM_LIST_INT(pColors) PARAM_INT(NumberOfCurves) PARAM_MEDIA(Mi) PARAM_INT_OPT(drawHalf, 0) PARAM_INT_OPT(Blend,0) PARAM_INT_OPT(HDIV, 0) PARAM_INT_OPT(VDIV, 0),
"Same as DrawCircle, See phiippe V for more info",
{
RS LocalRS;
Color4 colors[8];
GLOB_SetDefaultRS(&LocalRS);
LocalRS.BlendingMode = Blend;
LocalRS.USEVERTEXCOLORS = NbpColors > 0;
for (int i=0; i<8; i++)
{
colors[i] = Color4(pColors[i]);
}
if (!(SkipFunctions & SKIP_DRAWING))
DI->DrawPatch32(ID_MEDIA[Mi]->ulAssociatedTextureIndex,pCurves,colors,drawHalf,NumberOfCurves, HDIV, VDIV, &LocalRS);
})
DEFINE_SCRIPT(DRW_Patch32Normals,
CATEGORY(Drawing) PARAM_LIST_VECTOR(pCurves) PARAM_LIST_COLOR(pColors) PARAM_INT(NumberOfCurves) PARAM_MEDIA(Mi) PARAM_INT_OPT(drawHalf, 0) PARAM_INT_OPT(Blend,0) PARAM_INT_OPT(HDIV, 0) PARAM_INT_OPT(VDIV, 0) PARAM_INT_OPT(InvertInter, 0),
"Same as DRW_Patch32, but points 4-7 and 12-15 are normals",
{
RS LocalRS;
GLOB_SetDefaultRS(&LocalRS);
Color4 color[8];
LocalRS.BlendingMode = Blend;
LocalRS.USEVERTEXCOLORS = NbpColors > 0;
PatchPointsToNormals(pCurves, color, pColors, InvertInter);
if (!(SkipFunctions & SKIP_DRAWING))
DI->DrawPatch32(ID_MEDIA[Mi]->ulAssociatedTextureIndex,pCurves,color,drawHalf,NumberOfCurves,HDIV, VDIV,&LocalRS);
})
DEFINE_SCRIPT(PATCH32_XYZFromUV,
CATEGORY(PATCH32) PARAM_LIST_VECTOR(pCurves) PARAM_VECTOR(UV),
"get coord from UV",
{
Vector V = PatchGetXYZFromUV(pCurves, UV);
RETURN_VECTOR(&V);
})
DEFINE_SCRIPT(PATCH32_XYZFromUVNormals,
CATEGORY(PATCH32) PARAM_LIST_VECTOR(pCurves) PARAM_VECTOR(UV) PARAM_INT_OPT(InvertInter, 0),
"get coord from UV",
{
PatchPointsToNormals(pCurves, NULL, NULL, InvertInter);
Vector V = PatchGetXYZFromUV(pCurves, UV);
RETURN_VECTOR(&V);
})
DEFINE_SCRIPT(PATCH32_UVFromXYZ,
CATEGORY(PATCH32) PARAM_LIST_VECTOR(pCurves) PARAM_VECTOR(Point) PARAM_VECTOR_OPT(vMin, Vector()) PARAM_VECTOR_OPT(vMax, Vector(1,1,1)),
"get UV from coord",
{
Vector V = PatchGetUVFromXYZ(pCurves, Point, vMin, vMax);
RETURN_VECTOR(&V);
})
DEFINE_SCRIPT(PATCH32_UVFromXYZNormals,
CATEGORY(PATCH32) PARAM_LIST_VECTOR(pCurves) PARAM_VECTOR(Point) PARAM_VECTOR_OPT(vMin, Vector()) PARAM_VECTOR_OPT(vMax, Vector(1,1,1)) PARAM_INT_OPT(InvertInter, 0),
"get UV from coord",
{
PatchPointsToNormals(pCurves, NULL, NULL, InvertInter);
Vector V = PatchGetUVFromXYZ(pCurves, Point, vMin, vMax);
RETURN_VECTOR(&V);
})
DEFINE_SCRIPT_REN(DRW_Clear, Clear,
CATEGORY(Drawing) PARAM_COLOR_OPT(color, 0),
"Clear the current viewport",
{
if (!(SkipFunctions & SKIP_DRAWING))
{
color = ARGB2ABGR(color);
DI->Clear(color);
}
})
DEFINE_SCRIPT_REN(DRW_ClearZ, ClearZ,
CATEGORY(Drawing) ,
"Clear ZBuffer in the current viewport",
{
if (!(SkipFunctions & SKIP_DRAWING))
DI->ClearZ();
})
DEFINE_SCRIPT_REN(DRW_BackgroundSet, SetBackGround,
CATEGORY(Drawing) PARAM_MEDIA(Mi) PARAM_INT_OPT(Blendmode,0),
"Set the media as background in current viewport. You can specify blend mode",
{
if (!(SkipFunctions & SKIP_DRAWING))
DI->SetBackGround(ID_MEDIA[Mi]->ulAssociatedTextureIndex,(u32)Blendmode);
})
DEFINE_SCRIPT_REN(DRW_RenderColorSet, SetRenderColor,
CATEGORY(Drawing) PARAM_COLOR_OPT(color, 0),
"BLACK -> All is black<br/>WHITE -> All is normal<br/>Default is 255 255 255 255 (white)",
{
color = ARGB2ABGR(color);
DI->SetCurrentColor(color);
})
DEFINE_SCRIPT_REN(TRK_MediaSet, SetMediaToTrack,
CATEGORY(Tracking) PARAM_MEDIA(Mi),
"define the media where tracker is running",
{
MediaToTrack = Mi;
})
DEFINE_SCRIPT_REN(TRK_Reset, ResetT,
CATEGORY(Tracking) PARAM_INT_OPT(TrackID, -1),
"reset current tracker",
{
if (TrackID == -1) TrackID = CurrentID;
if (ID_TABLE[TrackID])
{
ID_Reset(TrackID);
}
})
DEFINE_SCRIPT(TRK_AutoBootStart,
CATEGORY(Tracking) PARAM_INT_OPT(TrackID, -1),
"reset current tracker",
{
if (TrackID == -1) TrackID = CurrentID;
if (ID_TABLE[TrackID])
{
ID_Reset(TrackID);
ID_AutoStart(TrackID);
}
})
DEFINE_SCRIPT(TRK_AutoBootStop,
CATEGORY(Tracking) PARAM_INT_OPT(ForceReset, 0) PARAM_INT_OPT(TrackID, -1),
"reset current tracker",
{
if (TrackID == -1) TrackID = CurrentID;
if (ID_TABLE[TrackID])
{
if (ForceReset)
ID_Reset(TrackID);
ID_TABLE[TrackID]->SF_U.ViolaStart = 0;
ID_TABLE[TrackID]->SF_U.Booted = 1;
ID_TABLE[TrackID]->SF_U.Ready2Learn = 1;
}
})
DEFINE_SCRIPT_REN(TRK_Save, SaveTrack,
CATEGORY(Tracking) PARAM_MEDIA_OPT(TrackedMedia, -1),
"<br/>Save track to file",
{
s32 TrackIndex;
s32 force = 0;
if (TrackedMedia == -1)
TrackedMedia = MediaToTrack;
if ((TrackedMedia != -1) && (ID_MEDIA[TrackedMedia]) &&
ID_MEDIA[TrackedMedia]->Tracks != NULL)
{
char TrackName[2048];
strcpy(TrackName,(char*)ID_MEDIA[TrackedMedia]->MediaName);
SetFileNameExtend(TrackName,'.TRK');
SaveTrackPlayer(ID_MEDIA[TrackedMedia]->Tracks,TrackName);
}
})
DEFINE_SCRIPT_REN(TRK_CurrentSet, SetCurrentTrack,
CATEGORY(Tracking) PARAM_INT(TrackIndex),
"Set current Track",
{
MediaCurrentTrack = TrackIndex;
})
DEFINE_SCRIPT(TRK_PosGet,
CATEGORY(Tracking) PARAM_AFFECT(Affect) PARAM_INT(TrackIndex) PARAM_MEDIA_OPT(TrackedMedia, -1) PARAM_INT_OPT(AxeInversion, 0) PARAM_INT_OPT(TimeLineCorrection, 0),
"Get the position matrix of the current tracked media previously set",
{
if (TrackedMedia == -1)
TrackedMedia = MediaToTrack;
if ((TrackedMedia != -1) && (ID_MEDIA[TrackedMedia]) && ID_MEDIA[TrackedMedia]->Tracks &&
TrackIndex < ID_MEDIA[TrackedMedia]->Tracks->ulNumberOfTracks &&
ID_MEDIA[TrackedMedia]->ulCurrentFrame < ID_MEDIA[TrackedMedia]->Tracks->TracksPtrs[TrackIndex].ulNumberOfMC)
{
MATRIX matrix;
Vector matrixScale;
int currFrame = ID_MEDIA[TrackedMedia]->ulCurrentFrame;
if (TimeLineCorrection)
{
currFrame = ID_MEDIA[TrackedMedia]->Tracks->GetTimeLine(currFrame, &ID_MEDIA[TrackedMedia]->Image);
}
//ID_MEDIA[TrackedMedia]->Tracks->Get(TrackIndex, currFrame, &matrix);
ID_MEDIA[TrackedMedia]->Tracks->Get(TrackIndex, ID_MEDIA[TrackedMedia]->dCurrentTime*ID_MEDIA[TrackedMedia]->dAvgFramePerSecond, &matrix);
SetSmoothMatrix(0, &matrix, Affect, AxeInversion);
if (Affect & 256)
{
ID_MEDIA[TrackedMedia]->Tracks->GetScale(TrackIndex,&matrixScale);
matrix.I *= matrixScale.x;
matrix.J *= matrixScale.z;
matrix.K *= matrixScale.y;
}
switch (Affect)
{
case 1: RETURN_VECTOR(&matrix.T);break;
case 4: RETURN_VECTOR(&matrix.I);break;
case 8: RETURN_VECTOR(&matrix.J);break;
case 16: RETURN_VECTOR(&matrix.K);break;
case 256: RETURN_VECTOR(&matrixScale);break;
case 258:
case 2: memset(&matrix.T, 0, sizeof(matrix.T));
case 0:
case 259:
case 3: RETURN_MATRIX(&matrix);break;
case 257: {
MATRIX ts;
ts.I *= matrixScale.x;
ts.J *= matrixScale.z;
ts.K *= matrixScale.y;
ts.T = matrix.T;
RETURN_MATRIX(&ts);
break;
}
}
}
})
DEFINE_SCRIPT(TRK_PosForce,
CATEGORY(Tracking) PARAM_INT(TrackIndex) PARAM_MATRIX(MatrixPos) PARAM_MEDIA_OPT(TrackedMedia, -1) PARAM_MEDIA_OPT(MediaSynchro, -1),
"Save a position matrix in current tracked media<br/>If force=1, the track is always saved<br/>If force=0, the track is only saved if it's empty",
{
if (TrackedMedia == -1)
TrackedMedia = MediaToTrack;
if (MediaSynchro == -1)
MediaSynchro = TrackedMedia;
if ((TrackedMedia != -1) && (ID_MEDIA[TrackedMedia]))
{
if (ID_MEDIA[TrackedMedia]->Tracks == NULL)
{
ID_MEDIA[TrackedMedia]->Tracks = (TrackPlayer*)CC_malloc(sizeof(TrackPlayer));
memset(ID_MEDIA[TrackedMedia]->Tracks,0,sizeof(TrackPlayer));
};
if (ID_TABLE[CurrentID])
{
Vector matrixScale;
matrixScale.x = MatrixPos.I.Norm(); MatrixPos.I.Normalize();
matrixScale.z = MatrixPos.J.Norm(); MatrixPos.J.Normalize();
matrixScale.y = MatrixPos.K.Norm(); MatrixPos.K.Normalize();
ID_MEDIA[TrackedMedia]->Tracks->Set(TrackIndex,ID_MEDIA[TrackedMedia]->ulCurrentFrame,
&MatrixPos, ID_TABLE[CurrentID]->SF_U.FlyStart + (ID_TABLE[CurrentID]->SF_U.FromScratch << 1));
ID_MEDIA[TrackedMedia]->Tracks->SetScale(TrackIndex,&matrixScale);
// Add to Test
ID_MEDIA[TrackedMedia]->Tracks->GetDescriptor(ID_MEDIA[TrackedMedia]->ulCurrentFrame)->ImageMarker =
GET_MARKER(&ID_MEDIA[MediaSynchro]->Image);
}
}
})
DEFINE_SCRIPT_REN(TRK_PosSet, TRK_PosSave,
CATEGORY(Tracking) PARAM_INT(TrackIndex) PARAM_MEDIA_OPT(TrackedMedia, -1) PARAM_INT_OPT(ForceSave, 1) PARAM_MEDIA_OPT(MediaSynchro, -1),
"Save current tracked position in current tracked media<br/>If force=1, the track is always saved<br/>If force=0, the track is only saved if it's empty",
{
if (TrackedMedia == -1)
TrackedMedia = MediaToTrack;
if (MediaSynchro == -1)
MediaSynchro = TrackedMedia;
if ((TrackedMedia != -1) && (ID_MEDIA[TrackedMedia]))
{
if (ID_MEDIA[TrackedMedia]->Tracks == NULL)
{
ID_MEDIA[TrackedMedia]->Tracks = (TrackPlayer*)CC_malloc(sizeof(TrackPlayer));
memset(ID_MEDIA[TrackedMedia]->Tracks,0,sizeof(TrackPlayer));
};
if (ID_TABLE[CurrentID])
{
if (TrackIndex >= ID_MEDIA[TrackedMedia]->Tracks->ulNumberOfTracks ||
ID_MEDIA[TrackedMedia]->ulCurrentFrame >=
ID_MEDIA[TrackedMedia]->Tracks->TracksPtrs[TrackIndex].ulNumberOfMC ||
IsMatriceCompressedNull(&ID_MEDIA[TrackedMedia]->Tracks->TracksPtrs[TrackIndex].pAnimation[ID_MEDIA[TrackedMedia]->ulCurrentFrame]))
ForceSave = 1;
if (ForceSave)
{
ID_MEDIA[TrackedMedia]->Tracks->Set(TrackIndex,ID_MEDIA[TrackedMedia]->ulCurrentFrame,
&ID_TABLE[CurrentID]->CurrentMatrix_UNS, ID_TABLE[CurrentID]->SF_U.FlyStart + (ID_TABLE[CurrentID]->SF_U.FromScratch << 1));
ID_MEDIA[TrackedMedia]->Tracks->SetScale(TrackIndex,&ID_TABLE[CurrentID]->vModelScale);
// Add to Test
ID_MEDIA[TrackedMedia]->Tracks->GetDescriptor(ID_MEDIA[TrackedMedia]->ulCurrentFrame)->ImageMarker =
GET_MARKER(&ID_MEDIA[MediaSynchro]->Image);
RETURN_BOOL(true);
} else
{ RETURN_BOOL(false);}
}
}
})
DEFINE_SCRIPT_REN(TRK_PosDel, DelTrackPos,
CATEGORY(Tracking) PARAM_INT(TrackIndex) PARAM_MEDIA_OPT(TrackedMedia, -1) PARAM_INT_OPT(beginPos, -1) PARAM_INT_OPT(endPos, -1),
"Delete tracked position in current tracked media<br/>If [Pos] and [End] are set, delete track from Pos to End<br/>If only [Pos] is set, delete the track at position [Pos]<br/>If neother [Pos] nor [End] are set, remove the current track ",
{
int CP;
if (TrackedMedia == -1)
TrackedMedia = MediaToTrack;
if ((TrackedMedia != -1) && (ID_MEDIA[TrackedMedia]))
{
if (ID_MEDIA[TrackedMedia]->Tracks == NULL)
{
ID_MEDIA[TrackedMedia]->Tracks = (TrackPlayer*)CC_malloc(sizeof(TrackPlayer));
memset(ID_MEDIA[TrackedMedia]->Tracks,0,sizeof(TrackPlayer));
}
if (ID_TABLE[CurrentID])
{
MATRIX nullMatrix;
nullMatrix.Clean();
if (beginPos == -1) beginPos = ID_MEDIA[TrackedMedia]->ulCurrentFrame;
if (endPos == -1) endPos = beginPos;
for (int idx=beginPos; idx<=endPos; idx++)
{
ID_MEDIA[TrackedMedia]->Tracks->Set(TrackIndex,idx, &nullMatrix, 0);
}
}
}
})
DEFINE_SCRIPT(TRK_TrackDel,
CATEGORY(Tracking) PARAM_INT(TrackIndex) PARAM_MEDIA_OPT(TrackedMedia, -1),
"Delete tracked position in current tracked media<br/>If [Pos] and [End] are set, delete track from Pos to End<br/>If only [Pos] is set, delete the track at position [Pos]<br/>If neother [Pos] nor [End] are set, remove the current track ",
{
int CP;
if (TrackedMedia == -1)
TrackedMedia = MediaToTrack;
if ((TrackedMedia != -1) && (ID_MEDIA[TrackedMedia]))
{
if (ID_MEDIA[TrackedMedia]->Tracks == NULL)
{
ID_MEDIA[TrackedMedia]->Tracks = (TrackPlayer*)CC_malloc(sizeof(TrackPlayer));
memset(ID_MEDIA[TrackedMedia]->Tracks,0,sizeof(TrackPlayer));
}
if (ID_TABLE[CurrentID])
{
ID_MEDIA[TrackedMedia]->Tracks->DelStream(TrackIndex);
}
}
})
DEFINE_SCRIPT_REN(TRK_CutsceneRefresh, RefreshCutScene,
CATEGORY(Tracking) PARAM_MEDIA_OPT(TrackedMedia, -1),
"Set if there is a cut scene or not",
{
TrackPlayer_Descriptors *descPtr;
if (TrackedMedia == -1)
TrackedMedia = MediaToTrack;
if (TrackedMedia != -1)
{
descPtr = ID_MEDIA[TrackedMedia]->Tracks->GetDescriptor(ID_MEDIA[TrackedMedia]->ulCurrentFrame);
if (descPtr)
{
if (WSPC && (WSPC->INTERP_MatchingPercent < 8.0f))
{
descPtr->Flags = descPtr->Flags | 1;
RETURN_INT(1);
} else
{
descPtr->Flags = descPtr->Flags & ~1;
RETURN_INT(0);
}
}
}
})
DEFINE_SCRIPT_REN(TRK_CutsceneSet, SetCutScene,
CATEGORY(Tracking) PARAM_MEDIA_OPT(TrackedMedia, -1) PARAM_INT_OPT(posIndex, -1),
"Force current media frame as a cut scene at specified position or current position",
{
TrackPlayer_Descriptors *descPtr;
if (TrackedMedia == -1)
TrackedMedia = MediaToTrack;
if ((TrackedMedia != -1) &&
(ID_MEDIA[TrackedMedia]))
{
if (ID_MEDIA[TrackedMedia]->Tracks == NULL)
{
ID_MEDIA[TrackedMedia]->Tracks = (TrackPlayer*)CC_malloc(sizeof(TrackPlayer));
memset(ID_MEDIA[TrackedMedia]->Tracks,0,sizeof(TrackPlayer));
};
if (posIndex == -1)
posIndex = ID_MEDIA[TrackedMedia]->ulCurrentFrame;
descPtr = ID_MEDIA[TrackedMedia]->Tracks->GetDescriptor(posIndex);
descPtr->Flags = descPtr->Flags | 1;
}
})
DEFINE_SCRIPT_REN(TRK_CutsceneDel, DelCutScene,
CATEGORY(Tracking) PARAM_MEDIA_OPT(TrackedMedia, -1) PARAM_INT_OPT(posIndex, -1),
"Force track as a cut scene at specified position or current position",
{
TrackPlayer_Descriptors *descPtr;
if (TrackedMedia == -1)
TrackedMedia = MediaToTrack;
if ((TrackedMedia != -1) &&
(ID_MEDIA[TrackedMedia]))
{
if (ID_MEDIA[TrackedMedia]->Tracks == NULL)
{
ID_MEDIA[TrackedMedia]->Tracks = (TrackPlayer*)CC_malloc(sizeof(TrackPlayer));
memset(ID_MEDIA[TrackedMedia]->Tracks,0,sizeof(TrackPlayer));
};
if (posIndex == -1)
posIndex = ID_MEDIA[TrackedMedia]->ulCurrentFrame;
descPtr = ID_MEDIA[TrackedMedia]->Tracks->GetDescriptor(posIndex);
descPtr->Flags = descPtr->Flags & ~1;
}
})
DEFINE_SCRIPT_REN(TRK_CutSceneTest, IsCutScene,
CATEGORY(Tracking) PARAM_MEDIA_OPT(TrackedMedia, -1) PARAM_INT_OPT(idxBegin, -1) PARAM_INT_OPT(idxEnd, -1),
"Return if the frame is a cutscene",
{
int nbReturn = 0;
BOOL returnList[1024];
if (TrackedMedia == -1)
TrackedMedia = MediaToTrack;
if ((TrackedMedia != -1) &&
(ID_MEDIA[TrackedMedia]))
{
if (idxBegin == -1) idxBegin = ID_MEDIA[TrackedMedia]->ulCurrentFrame;
if (idxEnd == -1) idxEnd = idxBegin;
if (ID_MEDIA[TrackedMedia]->Tracks)
{
if (idxEnd >= ID_MEDIA[TrackedMedia]->Tracks->ulNumberOfDescriptors)
idxEnd = ID_MEDIA[TrackedMedia]->Tracks->ulNumberOfDescriptors - 1;
if (idxEnd - idxBegin < 1024)
{
for (int idx = idxBegin; idx <= idxEnd; idx++)
returnList[nbReturn++] = ((ID_MEDIA[TrackedMedia]->Tracks->IsCutScene(idx)) ? 1 : 0);
}
}
}
if (nbReturn == 1)
{ RETURN_BOOL(returnList[0]); }
else if (nbReturn > 1)
{ RETURN_TABLE_INT(returnList, nbReturn); }
else
{ RETURN_BOOL(false); }
})
DEFINE_SCRIPT_REN(TRK_Count, GetNumTracks,
CATEGORY(Tracking) PARAM_MEDIA_OPT(TrackedMedia, -1),
"Return the number of tracks of the current tracked media",
{
if (TrackedMedia == -1)
TrackedMedia = MediaToTrack;
if ((TrackedMedia != -1) &&
ID_MEDIA[TrackedMedia]->Tracks)
{ RETURN_INT(ID_MEDIA[TrackedMedia]->Tracks->ulNumberOfTracks); }
})
DEFINE_SCRIPT_REN(TRK_NameGet, GetTrackName,
CATEGORY(Tracking) PARAM_INT(TrackIndex) PARAM_MEDIA_OPT(TrackedMedia, -1),
"Return the track's name",
{
if (TrackedMedia == -1)
TrackedMedia = MediaToTrack;
if ((TrackedMedia != -1) &&
ID_MEDIA[TrackedMedia]->Tracks &&
TrackIndex < ID_MEDIA[TrackedMedia]->Tracks->ulNumberOfTracks)
{ RETURN_STRING(ID_MEDIA[TrackedMedia]->Tracks->TracksPtrs[TrackIndex].Name); }
})
DEFINE_SCRIPT_REN(TRK_NameSet, SetTrackName,
CATEGORY(Tracking) PARAM_INT(TrackIndex) PARAM_STRING(Name) PARAM_MEDIA_OPT(TrackedMedia, -1),
"Set the track's name",
{
if (TrackedMedia == -1)
TrackedMedia = MediaToTrack;
if ((TrackedMedia != -1) &&
ID_MEDIA[TrackedMedia]->Tracks &&
TrackIndex < ID_MEDIA[TrackedMedia]->Tracks->ulNumberOfTracks)
{
strcpy(ID_MEDIA[TrackedMedia]->Tracks->TracksPtrs[TrackIndex].Name, Name);
}
})
DEFINE_SCRIPT_REN(TRK_Smooth, SmoothTracks,
CATEGORY(Tracking) PARAM_MEDIA(Mi) PARAM_INT_OPT(MaxSmooth, -1),
"Add lost images in tracker",
{
if (ID_MEDIA[Mi]->Tracks)
{
ID_MEDIA[Mi]->Tracks->Clean(MaxSmooth);
}
})
DEFINE_SCRIPT_REN(TRK_SmoothIO, SmoothTrackIO,
CATEGORY(Tracking) PARAM_INT(TrackIndex) PARAM_INT(begin) PARAM_INT(end) PARAM_MEDIA_OPT(TrackedMedia, -1),
"",
{
if (TrackedMedia == -1)
TrackedMedia = MediaToTrack;
if ((TrackedMedia != -1) && (ID_MEDIA[TrackedMedia]) &&
begin < end && end < ID_MEDIA[TrackedMedia]->Tracks->TracksPtrs[TrackIndex].ulNumberOfMC)
{
ID_MEDIA[TrackedMedia]->Tracks->CleanZone(TrackIndex, begin, end);
}
})
DEFINE_SCRIPT_REN(TRK_StatusGet, GetTrackStatus,
CATEGORY(Tracking) PARAM_INT(TrackeurID),
"return tracker state, like Islost with more info<br/>0: tracking ok<br/>1: traking on fly<br/>2: traking from scratch<br/>3: combination of 1 and 2<br/>8: no tracker",
{
if (!(SkipFunctions & SKIP_TRACKER))
{
int status;
if (TrackeurID >= MAX_ID) TrackeurID = MAX_ID-1;
if (TrackeurID < 0) TrackeurID= 0;
if (ID_TABLE[TrackeurID])
{
status = ID_TABLE[TrackeurID]->SF_U.FlyStart + (ID_TABLE[TrackeurID]->SF_U.FromScratch << 1);
} else
status = 8;
RETURN_INT(status);
}
//else
// RETURN_INT(8);
})
DEFINE_SCRIPT_REN(TRK_StatusSavedGet, GetSavedTrackStatus,
CATEGORY(Tracking) PARAM_INT(TrackeurID) PARAM_MEDIA_OPT(TrackedMedia, -1) PARAM_INT_OPT(trckBegin, -1) PARAM_INT_OPT(trckEnd, -1),
"return SAVED tracker state<br/>If [Track] is Set, returns the tracker save status at specified position<br/>Track States:<br/>0: tracking ok<br/>1: traking on fly<br/>2: traking from scratch<br/>3: combination of 1 and 2<br/>4: null track<br/> 8: no track made",
{
int trckPos;
int nbReturn = 0;
int returnList[1024];
if (TrackedMedia == -1)
TrackedMedia = MediaToTrack;
if (trckBegin == -1) trckBegin = ID_MEDIA[TrackedMedia]->ulCurrentFrame;
if (trckEnd == -1) trckEnd = trckBegin;
if (TrackeurID >= MAX_ID) TrackeurID = MAX_ID-1;
if (TrackeurID < 0) TrackeurID = 0;
if (ID_MEDIA[TrackedMedia]->Tracks &&
TrackeurID < ID_MEDIA[TrackedMedia]->Tracks->ulNumberOfTracks)
{
if (trckEnd >= ID_MEDIA[TrackedMedia]->Tracks->TracksPtrs[TrackeurID].ulNumberOfMC)
trckEnd = ID_MEDIA[TrackedMedia]->Tracks->TracksPtrs[TrackeurID].ulNumberOfMC - 1;
if (trckEnd - trckBegin < 2047)
{
for (trckPos=trckBegin; trckPos <= trckEnd; trckPos++)
{
if (IsMatriceCompressedNull(&ID_MEDIA[TrackedMedia]->Tracks->TracksPtrs[TrackeurID].pAnimation[trckPos]))
returnList[nbReturn++] = 4;
else
returnList[nbReturn++] = (int)(ID_MEDIA[TrackedMedia]->Tracks->TracksPtrs[TrackeurID].pAnimation[trckPos].IsValid & 3);
}
}
}
if (nbReturn == 1)
{ RETURN_INT(returnList[0]); }
else if (nbReturn > 1)
{ RETURN_TABLE_INT(returnList, nbReturn); }
else
{ RETURN_INT(8); }
})
DEFINE_SCRIPT_REN(TRK_ColorSet, SetTrackColor,
CATEGORY(Tracking) PARAM_INT(TrackIndex) PARAM_COLOR(color) PARAM_MEDIA_OPT(TrackedMedia, -1) PARAM_INT_OPT(posBegin, -1) PARAM_INT_OPT(posEnd, -1),
"Set color in track using",
{
int posIndex;
if (TrackedMedia == -1)
TrackedMedia = MediaToTrack;
if((TrackedMedia != -1) &&
(ID_MEDIA[TrackedMedia]))
{
if (ID_MEDIA[TrackedMedia]->Tracks == NULL)
{
ID_MEDIA[TrackedMedia]->Tracks = (TrackPlayer*)CC_malloc(sizeof(TrackPlayer));
memset(ID_MEDIA[TrackedMedia]->Tracks,0,sizeof(TrackPlayer));
};
if (posBegin == -1) posBegin = ID_MEDIA[TrackedMedia]->ulCurrentFrame;
if (posEnd == -1) posEnd = posBegin;
for (posIndex = posBegin; posIndex <= posEnd; posIndex++)
ID_MEDIA[TrackedMedia]->Tracks->SetSkinColor(TrackIndex, posIndex, color);
}
})
DEFINE_SCRIPT_REN(TRK_ColorGet, GetTrackColor,
CATEGORY(Tracking) PARAM_INT(TrackIndex) PARAM_MEDIA_OPT(TrackedMedia, -1) PARAM_INT_OPT(trckBegin, -1) PARAM_INT_OPT(trckEnd, -1),
"return SAVED tracker color in RGB mode",
{
int trckPos;
int strPos;
u32 color;
char resultStr[2048];
BOOL tableMode = false;
if (TrackedMedia == -1)
TrackedMedia = MediaToTrack;
memset(resultStr, 0, sizeof(resultStr));
if (trckBegin == -1) trckBegin = ID_MEDIA[TrackedMedia]->ulCurrentFrame;
if (trckEnd == -1) trckEnd = trckBegin;
else tableMode = true;
if (TrackIndex >= MAX_ID) TrackIndex = MAX_ID-1;
if (TrackIndex < 0) TrackIndex = 0;
if (ID_MEDIA[TrackedMedia]->Tracks &&
TrackIndex < ID_MEDIA[TrackedMedia]->Tracks->ulNumberOfTracks &&
trckBegin < ID_MEDIA[TrackedMedia]->Tracks->TracksPtrs[TrackIndex].ulNumberOfMC)
{
if (trckEnd >= ID_MEDIA[TrackedMedia]->Tracks->TracksPtrs[TrackIndex].ulNumberOfMC)
trckEnd = ID_MEDIA[TrackedMedia]->Tracks->TracksPtrs[TrackIndex].ulNumberOfMC - 1;
if (trckEnd - trckBegin < 256)
{
for (trckPos=trckBegin, strPos=0; trckPos <= trckEnd; trckPos++, strPos+=6)
{
color = ID_MEDIA[TrackedMedia]->Tracks->GetSkinColor(TrackIndex, trckPos);
sprintf(resultStr + strPos, "%06X", color);
}
resultStr[strPos] = 0;
}
if (tableMode)
{ RETURN_STRING(resultStr); }
else
{ RETURN_COLOR(color); }
}
})
DEFINE_SCRIPT(TRK_DataIntSet,
CATEGORY(Tracking) PARAM_INT(TrackIndex) PARAM_STRING(DataName) PARAM_INT(DataValue) PARAM_MEDIA_OPT(TrackedMedia, -1),
"Set integer data into .TRK <br/>if track index == -1, stocks in descriptor",
{
if (TrackedMedia == -1)
TrackedMedia = MediaToTrack;
if((TrackedMedia != -1) &&
(ID_MEDIA[TrackedMedia]))
{
if (ID_MEDIA[TrackedMedia]->Tracks == NULL)
{
ID_MEDIA[TrackedMedia]->Tracks = (TrackPlayer*)CC_malloc(sizeof(TrackPlayer));
memset(ID_MEDIA[TrackedMedia]->Tracks,0,sizeof(TrackPlayer));
};
RETURN_INT(ID_MEDIA[TrackedMedia]->Tracks->SetDataInt(TrackIndex,ID_MEDIA[TrackedMedia]->ulCurrentFrame, DataName, DataValue));
}
})
DEFINE_SCRIPT(TRK_DataIntGet,
CATEGORY(Tracking) PARAM_INT(TrackIndex) PARAM_STRING(DataName) PARAM_MEDIA_OPT(TrackedMedia, -1) PARAM_INT_OPT(FromFrame, -1) PARAM_INT_OPT(ToFrame, -1),
"Get integer data into .TRK <br/>if track index == -1, stocks in descriptor",
{
int returnInt;
if (TrackedMedia == -1)
TrackedMedia = MediaToTrack;
if (ID_MEDIA[TrackedMedia]->Tracks &&
(int)TrackIndex < (int)ID_MEDIA[TrackedMedia]->Tracks->ulNumberOfTracks)
{
if (ToFrame == -1)
ToFrame = ID_MEDIA[TrackedMedia]->ulCurrentFrame;
if (FromFrame != -1)
{
for (int fndIdx = FromFrame; fndIdx <= ToFrame; fndIdx++)
if (ID_MEDIA[TrackedMedia]->Tracks->GetDataInt(TrackIndex,fndIdx, DataName, &returnInt))
{ RETURN_INT_EVENT(returnInt, (double)fndIdx/ID_MEDIA[TrackedMedia]->dAvgFramePerSecond); }
} else
if (ID_MEDIA[TrackedMedia]->Tracks->GetDataInt(TrackIndex,ToFrame, DataName, &returnInt))
{ RETURN_INT_EVENT(returnInt, (double)ToFrame/ID_MEDIA[TrackedMedia]->dAvgFramePerSecond); }
}
})
DEFINE_SCRIPT(TRK_DataFloatSet,
CATEGORY(Tracking) PARAM_INT(TrackIndex) PARAM_STRING(DataName) PARAM_FLOAT(DataValue) PARAM_MEDIA_OPT(TrackedMedia, -1),
"Set float data into .TRK <br/>if track index == -1, stocks in descriptor",
{
if (TrackedMedia == -1)
TrackedMedia = MediaToTrack;
if((TrackedMedia != -1) &&
(ID_MEDIA[TrackedMedia]))
{
if (ID_MEDIA[TrackedMedia]->Tracks == NULL)
{
ID_MEDIA[TrackedMedia]->Tracks = (TrackPlayer*)CC_malloc(sizeof(TrackPlayer));
memset(ID_MEDIA[TrackedMedia]->Tracks,0,sizeof(TrackPlayer));
};
RETURN_INT(ID_MEDIA[TrackedMedia]->Tracks->SetDataFloat(TrackIndex,ID_MEDIA[TrackedMedia]->ulCurrentFrame, DataName, DataValue));
}
})
DEFINE_SCRIPT(TRK_DataFloatGet,
CATEGORY(Tracking) PARAM_INT(TrackIndex) PARAM_STRING(DataName) PARAM_MEDIA_OPT(TrackedMedia, -1) PARAM_INT_OPT(FromFrame, -1) PARAM_INT_OPT(ToFrame, -1),
"Get float data into .TRK <br/>if track index == -1, stocks in descriptor",
{
float returnFloat;
if (TrackedMedia == -1)
TrackedMedia = MediaToTrack;
if (ID_MEDIA[TrackedMedia]->Tracks &&
(int)TrackIndex < (int)ID_MEDIA[TrackedMedia]->Tracks->ulNumberOfTracks)
{
if (ToFrame == -1)
ToFrame = ID_MEDIA[TrackedMedia]->ulCurrentFrame;
if (FromFrame != -1)
{
for (int fndIdx = FromFrame; fndIdx <= ToFrame; fndIdx++)
if (ID_MEDIA[TrackedMedia]->Tracks->GetDataFloat(TrackIndex,fndIdx, DataName, &returnFloat))
{ RETURN_FLOAT_EVENT(returnFloat, (double)fndIdx/ID_MEDIA[TrackedMedia]->dAvgFramePerSecond); }
} else
if (ID_MEDIA[TrackedMedia]->Tracks->GetDataFloat(TrackIndex, ToFrame, DataName, &returnFloat))
{ RETURN_FLOAT_EVENT(returnFloat, (double)ToFrame/ID_MEDIA[TrackedMedia]->dAvgFramePerSecond); }
}
})
DEFINE_SCRIPT(TRK_DataStringSet,
CATEGORY(Tracking) PARAM_INT(TrackIndex) PARAM_STRING(DataName) PARAM_STRING(DataValue) PARAM_MEDIA_OPT(TrackedMedia, -1),
"Set string (256 max) data into .TRK <br/>if track index == -1, stocks in descriptor",
{
if (TrackedMedia == -1)
TrackedMedia = MediaToTrack;
if((TrackedMedia != -1) &&
(ID_MEDIA[TrackedMedia]))
{
if (ID_MEDIA[TrackedMedia]->Tracks == NULL)
{
ID_MEDIA[TrackedMedia]->Tracks = (TrackPlayer*)CC_malloc(sizeof(TrackPlayer));
memset(ID_MEDIA[TrackedMedia]->Tracks,0,sizeof(TrackPlayer));
};
RETURN_INT(ID_MEDIA[TrackedMedia]->Tracks->SetDataStr(TrackIndex,ID_MEDIA[TrackedMedia]->ulCurrentFrame, DataName, DataValue));
}
})
DEFINE_SCRIPT(TRK_DataStringGet,
CATEGORY(Tracking) PARAM_INT(TrackIndex) PARAM_STRING(DataName) PARAM_MEDIA_OPT(TrackedMedia, -1) PARAM_INT_OPT(FromFrame, -1) PARAM_INT_OPT(ToFrame, -1),
"Get string data into .TRK <br/>if track index == -1, stocks in descriptor",
{
char returnStr[256];
if (TrackedMedia == -1)
TrackedMedia = MediaToTrack;
if (ID_MEDIA[TrackedMedia]->Tracks &&
(int)TrackIndex < (int)ID_MEDIA[TrackedMedia]->Tracks->ulNumberOfTracks)
{
if (ToFrame == -1)
ToFrame = ID_MEDIA[TrackedMedia]->ulCurrentFrame;
if (FromFrame != -1)
{
for (int fndIdx = FromFrame; fndIdx <= ToFrame; fndIdx++)
if (ID_MEDIA[TrackedMedia]->Tracks->GetDataStr(TrackIndex,fndIdx, DataName, returnStr))
{ RETURN_STRING_EVENT(returnStr, (double)fndIdx/ID_MEDIA[TrackedMedia]->dAvgFramePerSecond); }
} else
if (ID_MEDIA[TrackedMedia]->Tracks->GetDataStr(TrackIndex,ToFrame, DataName, returnStr))
{ RETURN_STRING_EVENT(returnStr, (double)ToFrame/ID_MEDIA[TrackedMedia]->dAvgFramePerSecond); }
}
})
DEFINE_SCRIPT(APP_Log,
CATEGORY(Application) PARAM_STRING(log),
"Log text on DBG File",
{
void SaveDBGInfo(char *text);
SaveDBGInfo(log);
})
DEFINE_SCRIPT(APP_Error,
CATEGORY(Application),
"Force Error",
{
HandleError(L, luaParam);
})
#ifdef USER_MODE
DEFINE_SCRIPT(APP_UserModeTest,
CATEGORY(Application),
"Return if executable is compiled in user mode",
{
RETURN_BOOL(1);
})
DEFINE_SCRIPT(APP_VersionGet,
CATEGORY(Application),
"Return application version",
{
extern const char *VersionStr;
RETURN_STRING((char *)VersionStr);
})
#else
DEFINE_SCRIPT(APP_UserModeTest,
CATEGORY(Application),
"Return if executable is compiled in user mode",
{
RETURN_BOOL(0);
})
DEFINE_SCRIPT(APP_VersionGet,
CATEGORY(Application),
"Return application version",
{
extern u32 VersionNumber;
RETURN_INT(VersionNumber);
})
#endif
DEFINE_SCRIPT(APP_IsRestart,
CATEGORY(Application),
"Verify if application is on restart mode",
{
extern u32 IsRestart;
RETURN_BOOL(IsRestart);
})
DEFINE_SCRIPT(APP_CurrentUserGet,
CATEGORY(Application),
"Return application version",
{
extern DWORD CurrentSessionID;
RETURN_INT(CurrentSessionID);
})
DEFINE_SCRIPT(APP_LaunchUserGet,
CATEGORY(Application),
"Return application version",
{
extern DWORD LaunchSessionID;
RETURN_INT(LaunchSessionID);
})
DEFINE_SCRIPT(APP_GetDemoBranchFlag,
CATEGORY(Application),
"Return if the GameId of the application belongs to the Demo branch",
{
RETURN_BOOL(GetDemoBranchFlagFromRegistry());
})
DEFINE_SCRIPT(APP_GetFirstRunFlag,
CATEGORY(Application),
"Return false if the application has already been run with an account",
{
RETURN_BOOL(GetFirstRunFlag());
})
/*DEFINE_SCRIPT(APP_GetValueFromRegistry,
CATEGORY(Application), PARAM_STRING(Item), PARAM_BOOL(FromHKCU, true)
"Return the value of the item in HKCU/Software/Ubisoft/CamCam (or HKLM if From HKCU is false)",
{
char value[2048] = "";
GetCamCamValueFromRegistry(value, Item, FromHKCU));
RETURN_STRING(value);
})*/
DEFINE_SCRIPT(APP_GetInstalledLanguage,
CATEGORY(Application),
"Return the 2-character language code",
{
char languageCode[3] = "";
GetInstalledLanguageCode(languageCode);
RETURN_STRING(languageCode);
})
DEFINE_SCRIPT(APP_SplashScreenShow,
CATEGORY(Application) PARAM_INT_OPT(ON_OFF, 1),
"Show/Hide the splashscreen",
{
void ShowSplashScreen(bool show);
ShowSplashScreen((bool)ON_OFF);
})
DEFINE_SCRIPT(APP_SetGraphicDriver,
CATEGORY(Application) PARAM_INT(DriverNumber),
"0 for Opengl, 1 for D3D",
{
ChangeDriver(DriverNumber);
})
#ifdef ONLINE_MODE
DEFINE_SCRIPT(APP_GetYouUpBranch,
CATEGORY(Application),
"Return the YouUp Branch for this Exe (Demo, Beta, Release)",
{
RETURN_STRING(YOUUP_BRANCH);
})
DEFINE_SCRIPT(APP_GetYouUpOrigin,
CATEGORY(Application),
"Return the YouUp Origin (referrer) for this Exe",
{
RETURN_STRING(YOUUP_ORIGIN);
})
DEFINE_SCRIPT(APP_GetYouUpBranding,
CATEGORY(Application),
"Return the YouUp Branding for this Exe (MSN, Ubisoft)",
{
RETURN_STRING(YOUUP_ORIGIN);
})
DEFINE_SCRIPT(APP_Exit,
CATEGORY(Application),
"Kill application",
{
void API_EXIT();
API_EXIT();
})
DEFINE_SCRIPT(APP_AutorunSet,
CATEGORY(Application) PARAM_INT_OPT(ON_OFF, 1),
"Set autorun off application in windows startup",
{
int RegisterBoot(u32 add);
RegisterBoot(ON_OFF);
})
DEFINE_SCRIPT(APP_AutorunGet,
CATEGORY(Application),
"Get autorun off application in windows startup",
{
int RegisterBoot(u32 add);
int res = RegisterBoot(-1);
if (res >= 0)
{ RETURN_BOOL(res); }
})
#endif
DEFINE_SCRIPT(APP_AVI2FLV,
CATEGORY(Application) PARAM_STRING(AviPath) PARAM_STRING(FlvDest),
"Test Function - Convert AVI to FLV",
{
int AVI2FLV(char *avi, char *flv, bool *Aborted=NULL);
RETURN_BOOL(AVI2FLV(AviPath, FlvDest));
})
DEFINE_SCRIPT(APP_IconShow,
CATEGORY(Application) PARAM_INT_OPT(Show, 1),
"Show or hide tray icon",
{
void AnimateIcon(HINSTANCE hInstance, HWND hWnd, DWORD dwMsgType,UINT nIndexOfIcon,char *pInfoTexte);
if (Show)
{
AnimateIcon(NULL, OwnerHwnd, NIM_ADD,0,"");
} else
{
AnimateIcon(NULL, OwnerHwnd, NIM_DELETE,0,"");
}
})
DEFINE_SCRIPT(APP_DragFile,
CATEGORY(Application) PARAM_STRING(filename) PARAM_INT_OPT(moveFiles, 0),
"do drag and drop ...",
{
int DragAndDrop(char *path, bool moveFiles);
DragAndDrop(filename, (bool)moveFiles);
})
DEFINE_SCRIPT(APP_ForceKey,
CATEGORY(Application) PARAM_STRING(Key) PARAM_INT_OPT(IsUp,0) PARAM_INT_OPT(IsScanCode,0),
"",
{
void SendKeyMessage(DWORD code, int isScanCode, int isUp);
SendKeyMessage(*Key, IsScanCode, IsUp);
})
DEFINE_SCRIPT_REN(APP_Restart, APP_ExitInDriver,
CATEGORY(Application) PARAM_STRING_OPT(file, ""),
"",
{
if (*file )
strcpy(LuaScriptRestart, file);
else
strcpy(LuaScriptRestart, "driver.lua");
})
DEFINE_SCRIPT(APP_ForceMouse,
CATEGORY(Application) PARAM_INT(x) PARAM_INT(y) PARAM_INT_OPT(PressStatus,0),
"",
{
void SendMouseMessage(int x, int y, DWORD status);
SendMouseMessage(x,y,PressStatus);
})
DEFINE_SCRIPT_REN(APP_KeyPressTest, IsKeyPressed,
CATEGORY(Application) PARAM_INT_OPT(KeyNum, -1) PARAM_STRING_OPT(Key, ""),
"return 1 if one of the key is pressed",
{
BOOL keyPressed = false;
char *Parser;
if (*Key)
{
Parser = Key;
while (*Parser)
{
if (IsKeyPressed(*(Parser++))) keyPressed = true;
};
} else if (KeyNum != -1)
{
keyPressed = GetKeyState(KeyNum) & 0x80;
}
RETURN_BOOL(keyPressed);
})
DEFINE_SCRIPT_REN(APP_KeyUnpress, UnPressKey,
CATEGORY(Application) PARAM_STRING(Keys),
"unpress the specifyed key(s)",
{
char *Parser;
Parser = Keys;
while (*Parser)
{
UnPressKey(*(Parser++));
}
})
DEFINE_SCRIPT(APP_KeyGet,
CATEGORY(Application),
"Get current pressed char key",
{
char MyCharString[2];
MyCharString[0] = LastKeyPressed;
MyCharString[1] = 0;
RETURN_STRING(MyCharString);
})
DEFINE_SCRIPT_REN(APP_MousePressTest, IsMousePressed,
CATEGORY(Application) PARAM_INT_OPT(TestEvenWithNoFocus, 0),
"return true if left mouse button is pressed",
{
if (!TestEvenWithNoFocus && !CheckFocus())
{
RETURN_BOOL(0);
} else
{
RETURN_BOOL((GetAsyncKeyState(VK_LBUTTON) & 0x8000));
}
})
DEFINE_SCRIPT(APP_Explore,
CATEGORY(Application) PARAM_STRING(path),
"open explorer at specified path",
{
char TEXT[2048];
sprintf(TEXT,"CMD /C START explorer %s", path);
WinExec(TEXT,SW_HIDE);
})
#ifdef RASTERS_ACTIVATED
DEFINE_SCRIPT(APP_RasterStart,
CATEGORY(Application) PARAM_INT(index) PARAM_STRING_OPT(Name, ""),
"Set Raster, 0 &lt;= index &lt;= 4",
{
if (*Name)
StartRaster((RASTER_ENUM)(RAS_SCRIPT_Raster1+index), Name);
else
StartRaster((RASTER_ENUM)(RAS_SCRIPT_Raster1+index));
})
DEFINE_SCRIPT(APP_RasterStop,
CATEGORY(Application) PARAM_INT(index),
"Set Raster, 0 &lt;= index &lt;= 4",
{
StopRaster((RASTER_ENUM)(RAS_SCRIPT_Raster1+index));
})
#else
DEFINE_SCRIPT(APP_RasterStart,
CATEGORY(Application) PARAM_INT(index) PARAM_STRING_OPT(Name, ""),
"Set Raster, 0 &lt;= index &lt;= 4",
{
})
DEFINE_SCRIPT(APP_RasterStop,
CATEGORY(Application) PARAM_INT(index),
"Set Raster, 0 &lt;= index &lt;= 4",
{
})
#endif
DEFINE_SCRIPT(APP_ScreenMouseThresholdSet,
CATEGORY(Application) PARAM_FLOAT(Threshold),
"Set screen mouse noise threshold, set a small value for a big smooth",
{
extern float NoisThreshold;
NoisThreshold = Threshold;
})
DEFINE_SCRIPT(APP_AVISaveConfig,
CATEGORY(Application) PARAM_STRING(SaveFile) PARAM_INT_OPT(UseSound, 0) PARAM_STRING_OPT(FilterName, "") PARAM_INT_OPT(Width, 0) PARAM_INT_OPT(Height, 0),
"Create and config avi file writer",
{
CreateMedia(SaveFile, 0, true);
RETURN_BOOL(SaveInFile_Config(SaveFile, UseSound, FilterName, Width, Height));
})
DEFINE_SCRIPT(APP_AVISaveSourceSet,
CATEGORY(Application) PARAM_INT(OnResultFrame) PARAM_MEDIA_OPT(media, -1),
"Set Avi writer source if onResultFrame == 1, use total screen, else, use a specific media. DO IT BEFORE START !!!",
{
SaveInFile_SetSource(OnResultFrame, media);
})
DEFINE_SCRIPT(APP_AVISaveAudioSourceAdd,
CATEGORY(Application) PARAM_STRING(media),
"Add an audio source to Record. DO IT BEFORE START !!!",
{
RETURN_INT(SaveInFile_AddInputData(media));
})
DEFINE_SCRIPT(APP_AVISaveAudioSourceSeek,
CATEGORY(Application) PARAM_INT(inputIndex) PARAM_FLOAT(time),
"Seek audio source. DO IT BEFORE START !!!",
{
RETURN_BOOL(SaveInFile_SeekInputData(inputIndex, time));
})
#ifdef VIDEO_OPENLIB
DEFINE_SCRIPT(APP_AVISaveAudioSourceSkip,
CATEGORY(Application) PARAM_INT(inputIndex) PARAM_INT_OPT(skip, 1),
"Skip audio source. THIS FUNCTION DO NOT REMOVE THE INPUT",
{
RETURN_BOOL(SaveInFile_SkipInputData(inputIndex, skip));
})
#endif
#ifndef USE_WMV
DEFINE_SCRIPT(APP_AVISaveExtension,
CATEGORY(Application),
"Return video file extension",
{
RETURN_STRING(".avi");
})
#else
DEFINE_SCRIPT(APP_AVISaveExtension,
CATEGORY(Application),
"Return video file extension",
{
RETURN_STRING(".wmv");
})
#endif
DEFINE_SCRIPT(APP_AVISaveStart,
CATEGORY(Application),
"Start save",
{
if (!SaveInFile_Init())
{
SaveInFile_Stop();
RETURN_BOOL(0);
} else
{
RETURN_BOOL(1);
}
})
DEFINE_SCRIPT(APP_AVISaveRun,
CATEGORY(Application),
"Begin AVI Save (need AVISaveConfig)",
{
RETURN_BOOL(SaveInFile_Run());
})
DEFINE_SCRIPT(APP_AVISavePause,
CATEGORY(Application),
"Pause AVI Save (need AVISaveConfig)",
{
RETURN_BOOL(SaveInFile_Pause());
})
DEFINE_SCRIPT(APP_AVISaveStop,
CATEGORY(Application),
"Stop and remove AVI save mode (need AVISaveConfig), after a stop a Config is needed again",
{
RETURN_BOOL(SaveInFile_Stop());
})
DEFINE_SCRIPT(APP_Sleep,
CATEGORY(Application) PARAM_INT(SleepTime),
"Sleep application (time in milliseconds)",
{
Sleep(SleepTime);
})
DEFINE_SCRIPT(APP_DirWatch,
CATEGORY(Application) PARAM_STRING_OPT(Directory, ""),
"Set Lua watch to specified directory (only on watch at the same time), if file is modified, the lua event onDirWatch is send",
{
int DWLua_WatchDirectory(char *DirectoryToWatch, void *pS);
int DWLua_UnWatchDirectory();
if (*Directory)
DWLua_WatchDirectory(Directory, (void *)this);
else
DWLua_UnWatchDirectory();
})
DEFINE_SCRIPT(APP_ApplicationDataPathGet,
CATEGORY(Application),
"Get user application data path",
{
extern char AppDataPath[];
RETURN_STRING(AppDataPath);
})
DEFINE_SCRIPT(APP_MyDocsPathGet,
CATEGORY(Application),
"Get user My Documents path",
{
extern char MyDocsPath[];
RETURN_STRING(MyDocsPath);
})
DEFINE_SCRIPT(APP_MyMusicPathGet,
CATEGORY(Application),
"Get user My Music path",
{
extern char MyMusicsPath[];
RETURN_STRING(MyMusicsPath);
})
DEFINE_SCRIPT(APP_MyPicturesPathGet,
CATEGORY(Application),
"Get user My Pictures path",
{
extern char MyPicturesPath[];
RETURN_STRING(MyPicturesPath);
})
DEFINE_SCRIPT(APP_SimConnect,
CATEGORY(Application) PARAM_INT_OPT(newDelta, 0) PARAM_INT_OPT(close, 0) PARAM_FLOAT_OPT(xFactor, 1) PARAM_FLOAT_OPT(yFactor, 1) PARAM_FLOAT_OPT(zFactor, 1) PARAM_FLOAT_OPT(rFactor, 1) PARAM_FLOAT_OPT(tSmooth, 0) PARAM_FLOAT_OPT(rSmooth, 0),
"Connection To Flight simulator",
{
void testCockpitCamera(bool close, bool newDelta, float xFactor, float yFactor, float zFactor, float rFactor, float tSmoothFactor, float rSmoothFactor);
testCockpitCamera(close, newDelta, xFactor, yFactor, zFactor, rFactor, tSmooth, rSmooth);
})
DEFINE_SCRIPT(APP_BlazingConnect,
CATEGORY(Application) PARAM_INT_OPT(init, 0) PARAM_MATRIX(matrix) PARAM_FLOAT_OPT(ratio, 1.0f),
"Connection To Flight simulator",
{
bool SendCommandToBlazingAngel(MATRIX *matrix, bool init, float ratio);
RETURN_BOOL(SendCommandToBlazingAngel(&matrix, init, ratio));
})
DEFINE_SCRIPT(FILE_Exists,
CATEGORY(File) PARAM_STRING(filename),
"Verify if file exists and can be Opened !",
{
FILE *file;
file = fopen(filename, "r");
if (file)
{
fclose(file);
RETURN_BOOL(1);
} else
{
RETURN_BOOL(0);
}
})
DEFINE_SCRIPT(FILE_Copy,
CATEGORY(File) PARAM_STRING(src) PARAM_STRING(dst),
"Copy specified file",
{
RETURN_BOOL(CopyFile(src, dst, 0));
})
DEFINE_SCRIPT(FILE_Move,
CATEGORY(File) PARAM_STRING(src) PARAM_STRING(dst),
"Move specified file",
{
RETURN_BOOL(MoveFile(src, dst));
})
DEFINE_SCRIPT(FILE_Delete,
CATEGORY(File) PARAM_STRING(filename),
"Delete specified file",
{
RETURN_BOOL(DeleteFile(filename));
})
DEFINE_SCRIPT(FILE_DirCreate,
CATEGORY(File) PARAM_STRING(dirname),
"Create specified directory",
{
RETURN_BOOL(CreateDirectory(dirname, NULL));
})
DEFINE_SCRIPT_REN(DRW_MediaPoint, DrawPoint,
CATEGORY(Drawing) PARAM_INT(X) PARAM_INT(Y) PARAM_MEDIA(Mi) PARAM_COLOR(ColorRGB) PARAM_INT(Opacity) PARAM_INT(Diam) PARAM_INT(CursorMode),
"Draw one pixel with the specified color into the media at position X,Y<br/>Modes 0: Paint - 1:Cursor - 2:RemoveCursor",
{
if (!(SkipFunctions & SKIP_DRAWING))
{
POINT XY;
XY.x = X; XY.y = Y;
if (ID_MEDIA[Mi]->Image.GetBase())
{
if (CursorMode & 4)
{
if (prevMousePointSet && (CursorMode & 3)) {
PaintCursor(&ID_MEDIA[Mi]->Image, prevMousePoint, prevDiam);
}
prevMousePointSet = 0;
prevMousePoint.x =
prevMousePoint.y = 0;
} else if ( XY.x >= 0 && XY.x < ID_MEDIA[Mi]->Image.SX &&
XY.y >= 0 && XY.y < ID_MEDIA[Mi]->Image.SY )
{
if (CursorMode == 0 || CursorMode & 1)
Paint(&ID_MEDIA[Mi]->Image, XY, prevMousePoint, ColorRGB, Opacity, Diam);
if (CursorMode & 2)
{
PaintCursor(&ID_MEDIA[Mi]->Image, XY, Diam);
}
prevMousePointSet = 1;
prevMousePoint = XY;
prevDiam = Diam;
}
if (ID_MEDIA[Mi]->ulAssociatedTextureIndex != -1)
DI->UpdateTexture_BM_2_HW(ID_MEDIA[Mi]->ulAssociatedTextureIndex);
}
}
})
DEFINE_SCRIPT_REN(SCN_MorphSet, SetMorph,
CATEGORY(Small Scene) PARAM_SCENE(SmSc) PARAM_STRING_OPT(ObjectName, "") PARAM_LIST_FLOAT(WeightList),
"",
{
char ObjectNameOBJ[2048];
UnicID ObjectREF = -1;
if (*ObjectName != 0)
{
sprintf(ObjectNameOBJ, "%s.OBJ", ObjectName);
ObjectREF = SmSc->ObjectNameDico.IsExist(ObjectNameOBJ);
if (ObjectREF != -1)
{
ObjectREF = SmSc->ObjectNameDico.mpst_Dico[ObjectREF].AssociatedValue;
if (ObjectREF != -1)
ObjectREF = SmSc->ObjectsPtrs[ObjectREF]->MeshIndex;
}
}
for (u32 MeshIndex = 0; MeshIndex < SmSc->ulNumberOfMeshes ; MeshIndex++)
{
if ((ObjectREF == -1 || ObjectREF == MeshIndex) && SmSc->MeshesPtrs[MeshIndex])
{
for (int MorphIndex=0; MorphIndex<NbWeightList; MorphIndex++)
{
if (MorphIndex < SmSc->MeshesPtrs[MeshIndex]->ulNumberOfTarget)
SmSc->MeshesPtrs[MeshIndex]->MorphTargets[MorphIndex].Weight = WeightList[MorphIndex];
}
}
}
})
DEFINE_SCRIPT(SCN_MorphGet,
CATEGORY(Small Scene) PARAM_SCENE(SmSc) PARAM_STRING(ObjectName),
"",
{
char ObjectNameOBJ[2048];
UnicID ObjectREF = -1;
sprintf(ObjectNameOBJ, "%s.OBJ", ObjectName);
ObjectREF = SmSc->ObjectNameDico.IsExist(ObjectNameOBJ);
if (ObjectREF != -1)
{
ObjectREF = SmSc->ObjectNameDico.mpst_Dico[ObjectREF].AssociatedValue;
if (ObjectREF != -1)
ObjectREF = SmSc->ObjectsPtrs[ObjectREF]->MeshIndex;
}
if (ObjectREF != -1 && SmSc->MeshesPtrs[ObjectREF])
{
for (int MorphIndex=0; MorphIndex<SmSc->MeshesPtrs[ObjectREF]->ulNumberOfTarget; MorphIndex++)
{
RETURN_FLOAT(SmSc->MeshesPtrs[ObjectREF]->MorphTargets[MorphIndex].Weight);
}
}
})
DEFINE_SCRIPT_REN(APP_TimeGet, GetTime,
CATEGORY(Application) ,
"Return actual time in milliseconds",
{
DWORD curTime = timeGetTime();
RETURN_INT(curTime); //// A VOIR
})
DEFINE_SCRIPT(APP_DateGet,
CATEGORY(Application) ,
"Return a string of actual date",
{
SYSTEMTIME st;
GetSystemTime(&st);
RETURN_DATE(st);
})
DEFINE_SCRIPT(APP_CursorHide,
CATEGORY(Application) PARAM_INT_OPT(ON_OFF, 0),
"Show or hide WINDOWS cursor",
{
ShowCursor(!ON_OFF);
})
DEFINE_SCRIPT_REN(APP_Cursor, APP_CursorHand,
CATEGORY(Application) PARAM_INT_OPT(CursorType, 0) PARAM_STRING_OPT(CursorPath, ""),
"Show a specified cursor<br/>0 - Standard cursor<br/>1 - Hand cursor<br/>2 - Wait cursor<br/>3 - Resize Cursor NWSE <br/>4 - Resize Cursor NESW <br/>5 - Move Cursor",
{
void ChangeCursor(char *cursor);
void ChangeCursorFromFile(char *cursorPath);
if (CursorType == 0)
ChangeCursor(IDC_ARROW);
if (CursorType == 1)
ChangeCursor(IDC_HAND);
if (CursorType == 2)
ChangeCursor(IDC_WAIT);
if (CursorType == 3)
ChangeCursor(IDC_SIZENWSE);
if (CursorType == 4)
ChangeCursor(IDC_SIZENESW);
if (CursorType == 5)
ChangeCursor(IDC_SIZEALL);
if (CursorPath && *CursorPath)
ChangeCursorFromFile(CursorPath);
})
DEFINE_SCRIPT_REN(TRK_MeshShow, ShowMesh,
CATEGORY(Tracking) PARAM_INT_OPT(ON_OFF, -1),
"Show the tracked mesh... And return the state ",
{
if (ID_TABLE[CurrentID])
{
if (ON_OFF == -1)
ID_TABLE[CurrentID]->SF_U.DrawMesh = !ID_TABLE[CurrentID]->SF_U.DrawMesh;
else
{
if (ON_OFF) ID_TABLE[CurrentID]->SF_U.DrawMesh = 1;
else ID_TABLE[CurrentID]->SF_U.DrawMesh = 0;
}
RETURN_BOOL(ID_TABLE[CurrentID]->SF_U.DrawMesh);
};
})
DEFINE_SCRIPT_REN(SCN_ObjectLookAtSet, SetObjectLookAt,
CATEGORY(Small Scene) PARAM_AFFECT(Affect) PARAM_SCENE(Smsc) PARAM_STRING(ObjectName) PARAM_STRING_OPT(ObjectLookAt, ""),
"",
{
char ObjectNameOBJ[2048];
s32 Number;
sprintf(ObjectNameOBJ,"%s.OBJ",ObjectName);
UnicID ObjectREF;
ObjectREF = Smsc->ObjectNameDico.IsExist(ObjectNameOBJ);
if (ObjectREF != -1)
{
MATRIX LookWhat;
UnicID ObjectREFLA;
ObjectREF = Smsc->ObjectNameDico.mpst_Dico[ObjectREF].AssociatedValue;
ObjectREFLA = -1;
if (*ObjectLookAt != 0)
{
sprintf(ObjectNameOBJ,"%s.OBJ",ObjectLookAt);
ObjectREFLA = Smsc->ObjectNameDico.IsExist(ObjectNameOBJ);
if (ObjectREFLA != -1)
ObjectREFLA = Smsc->ObjectNameDico.mpst_Dico[ObjectREFLA].AssociatedValue;
};
ComputeSmallSceneObjectLookAt(Smsc,Affect,ObjectREF,ObjectREFLA);
}
})
#ifndef SKIMMED_NET
DEFINE_SCRIPT_REN(NET_IDGetSet, Net_GetSetID,
CATEGORY(Network),
"Get Network ID and set it as currentID",
{
int myIdex = 0;
for (u32 netIdx=0; netIdx<32; netIdx++)
{
if ((NetObj->ValidMask & 1<<netIdx) &&
(NetObj->LinkedIP[netIdx].ulIP < NetObj->MyulIP))
myIdex++;
}
CurrentID = myIdex;
if (ID_TABLE[CurrentID] == NULL)
ID_New(CurrentID);
RETURN_INT( CurrentID);
})
DEFINE_SCRIPT_REN(NET_IDCount, Net_GetNbID,
CATEGORY(Network),
"Get Number of connected machine",
{
int nbID = 1; // myID
for (u32 netIdx=0; netIdx<32; netIdx++)
{
if (NetObj->ValidMask & (1<<netIdx))
nbID++;
}
RETURN_INT( nbID);
})
DEFINE_SCRIPT_REN(NET_IPGetFromID, Net_GetIPFromID,
CATEGORY(Network) PARAM_INT(theID),
"Get Network IP of a specific ",
{
if (theID == CurrentID)
{ RETURN_STRING( NetObj->MyIP); }
else
{
u32 netIdx;
u32 netIdxIn;
if (theID > CurrentID) theID--;
for (netIdx=0; netIdx<32; netIdx++)
{
if (NetObj->ValidMask & 1<<netIdx)
{
int curIPPos = 0;
for (netIdxIn=0; netIdxIn<32; netIdxIn++)
{
if (netIdxIn == netIdx) continue;
if ((NetObj->ValidMask & 1<<netIdxIn) &&
(NetObj->LinkedIP[netIdxIn].ulIP < NetObj->LinkedIP[netIdx].ulIP))
curIPPos++;
}
if (curIPPos == theID)
break;
}
}
char IPBuffer[256];
sprintf(IPBuffer, "%d.%d.%d.%d", (NetObj->LinkedIP[netIdx].ulIP >> 24) & 0xFF,
(NetObj->LinkedIP[netIdx].ulIP >> 16) & 0xFF,
(NetObj->LinkedIP[netIdx].ulIP >> 8) & 0xFF,
(NetObj->LinkedIP[netIdx].ulIP >> 0) & 0xFF);
RETURN_STRING(IPBuffer);
}
})
#endif
DEFINE_SCRIPT_REN(APP_CollisionSet, Collision_Set,
CATEGORY(Application) PARAM_INT(ON_OFF),
"Set or remove collision process",
{
CollisionOn = ON_OFF;
})
#ifndef SKIMMED_NET
DEFINE_SCRIPT(NET_GetMyIP,
CATEGORY(Network),
"return this PC IP as 10.10.10.10",
{
RETURN_STRING(NetObj->MyIP);
})
#endif
DEFINE_SCRIPT_REN(SCN_ObjectHideSet, SetHideObject,
CATEGORY(Small Scene) PARAM_INT(Hide) PARAM_SCENE(Smsc) PARAM_STRING_OPT(ObjectName, "") PARAM_INT_OPT(AffectChildren, 1),
"Hide or unhide an object and all his son's.<br/>His nothing do it for all",
{
char ObjectNameOBJ[2048];
UnicID ObjectREF;
ObjectREF = 0;
if(*ObjectName != 0)
{
ObjectREF = Smsc->ObjectNameDico.IsExist(ObjectName);
if (ObjectREF == -1)
{
sprintf(ObjectNameOBJ,"%s.OBJ",ObjectName);
ObjectREF = Smsc->ObjectNameDico.IsExist(ObjectNameOBJ);
}
if (ObjectREF != -1)
ObjectREF = Smsc->ObjectNameDico.mpst_Dico[ObjectREF].AssociatedValue;
} else ObjectREF = 0;
if (ObjectREF != -1) SmallScene_HideObject(Smsc,ObjectREF,Hide,AffectChildren);
})
DEFINE_SCRIPT(SCN_ObjectHideGet,
CATEGORY(Small Scene) PARAM_SCENE(Smsc) PARAM_STRING_OPT(ObjectName, ""),
"Tell if object is Hidden",
{
char ObjectNameOBJ[2048];
UnicID ObjectREF;
ObjectREF = 0;
if(*ObjectName != 0)
{
ObjectREF = Smsc->ObjectNameDico.IsExist(ObjectName);
if (ObjectREF == -1)
{
sprintf(ObjectNameOBJ,"%s.OBJ",ObjectName);
ObjectREF = Smsc->ObjectNameDico.IsExist(ObjectNameOBJ);
}
if (ObjectREF != -1)
ObjectREF = Smsc->ObjectNameDico.mpst_Dico[ObjectREF].AssociatedValue;
} else ObjectREF = 0;
if (ObjectREF != -1)
{ RETURN_BOOL(Smsc->ObjectsPtrs[ObjectREF]->Flags.HIDEN); }
})
DEFINE_SCRIPT_REN(SCN_ObjectOriginalPosSet, SetPosObjectOriginal,
CATEGORY(Small Scene) PARAM_SCENE(Smsc) PARAM_STRING_OPT(ObjectName, ""),
"Restore an object initial position all his son's.<br/>his nothing do it for all",
{
char ObjectNameOBJ[2048];
UnicID ObjectREF;
ObjectREF = 0;
if(*ObjectName != 0)
{
ObjectREF = Smsc->ObjectNameDico.IsExist(ObjectName);
if (ObjectREF == -1)
{
sprintf(ObjectNameOBJ,"%s.OBJ",ObjectName);
ObjectREF = Smsc->ObjectNameDico.IsExist(ObjectNameOBJ);
}
if (ObjectREF != -1)
{
ObjectREF = Smsc->ObjectNameDico.mpst_Dico[ObjectREF].AssociatedValue;
}
} else ObjectREF = 0;
if (ObjectREF != -1) SmallScene_RestoreInitialPosition(Smsc,ObjectREF);
})
DEFINE_SCRIPT(SCN_ObjectStateSave,
CATEGORY(Small Scene) PARAM_SCENE(Smsc) PARAM_STRING_OPT(ObjectName, "") PARAM_INT_OPT(index, 0) PARAM_INT_OPT(mask, 7),
"Save object states<br/>mask : 1- Flags; 2- LocalMatrix; 4- Draworder",
{
char ObjectNameOBJ[2048];
sprintf(ObjectNameOBJ,"%s.OBJ",ObjectName);
UnicID ObjectREF;
ObjectREF = Smsc->ObjectNameDico.IsExist(ObjectNameOBJ);
if (ObjectREF != -1)
ObjectREF = Smsc->ObjectNameDico.mpst_Dico[ObjectREF].AssociatedValue;
SmallScene_ObjectStateSave(Smsc, ObjectREF , index, mask);
})
DEFINE_SCRIPT(SCN_ObjectStateRestore,
CATEGORY(Small Scene) PARAM_SCENE(Smsc) PARAM_STRING_OPT(ObjectName, "") PARAM_INT_OPT(index, 0) PARAM_INT_OPT(mask, 7),
"Restore object states <br/>mask : 1- Flags; 2- LocalMatrix; 4- Draworder",
{
char ObjectNameOBJ[2048];
sprintf(ObjectNameOBJ,"%s.OBJ",ObjectName);
UnicID ObjectREF;
ObjectREF = Smsc->ObjectNameDico.IsExist(ObjectNameOBJ);
if (ObjectREF != -1)
ObjectREF = Smsc->ObjectNameDico.mpst_Dico[ObjectREF].AssociatedValue;
RETURN_INT(SmallScene_ObjectStateRestore(Smsc, ObjectREF, index, mask));
})
DEFINE_SCRIPT_REN(TRK_CameraMove, MoveCam,
CATEGORY(Tracking) PARAM_AFFECT(Affect) PARAM_INT(TrackeurID) PARAM_SCENE(Smsc) PARAM_INT_OPT(SmoothModeNumber,0),
"Warning ! this must be called BEFORE SetTrackMatrix !!",
{
int TRID = TrackeurID;
if (TRID >= MAX_ID) TRID = MAX_ID-1;
if (TRID < 0) TRID = 0;
if (ID_TABLE[TRID])
{
if (!ID_TABLE[TRID]->SF_U.Booted || bManualBoot) Affect = 0;
MoveSceneCamera(SmoothModeNumber, Smsc, Affect, ID_TABLE[TRID]);
}
})
DEFINE_SCRIPT(TRK_PadHandle,
CATEGORY(Tracking) PARAM_AFFECT(Affect) PARAM_INT(index) PARAM_MATRIX(Matrix) PARAM_INT(SmoothNumber) PARAM_FLOAT(maxAngle),
"Handle PPJoy",
{
char error[2048];
void HandlePad(int SmoothNumber, int Affect, MATRIX *pTrckMatrix, float maxAngle, char *error);
HandlePad(SmoothNumber, Affect, &Matrix, maxAngle, error);
RETURN_STRING(error);
})
DEFINE_SCRIPT(TRK_ResolutionSet,
CATEGORY(Tracking) PARAM_INT(Resolution),
"Change track resolution",
{
trackSize = Resolution;
})
DEFINE_SCRIPT(TRK_FactorTranslationSet,
CATEGORY(Tracking) PARAM_FLOAT(TFactor),
"Set translation factor multiplier",
{
FrmFactorTranslation = TFactor;
})
DEFINE_SCRIPT(TRK_FactorRotationSet,
CATEGORY(Tracking) PARAM_FLOAT(RFactor),
"Set rotation factor multiplier",
{
FrmFactorRotation = RFactor;
})
DEFINE_SCRIPT(TRK_FactorRotationLimitSet,
CATEGORY(Tracking) PARAM_FLOAT(RLimit),
"Set rotation factor multiplier",
{
FrmFactorRotationLimit = RLimit;
})
DEFINE_SCRIPT(TRK_SmoothTranslationSet,
CATEGORY(Tracking) PARAM_FLOAT(TSmooth) PARAM_FLOAT_OPT(THold, 0.0),
"Set translation smooth factor, number between 0 and 1, 1-> no smooth, 0-> no move",
{
FrmSmooth.Translation = TSmooth;
FrmSmooth.TranslationHold = THold;
})
DEFINE_SCRIPT(TRK_SmoothRotationSet,
CATEGORY(Tracking) PARAM_FLOAT(RSmooth),
"Set rotation smooth factor, default 2, the bigger is the number, the smaller is the smooth",
{
FrmSmooth.Rotation = RSmooth;
})
DEFINE_SCRIPT(TRK_SmoothQuatSet,
CATEGORY(Tracking) PARAM_FLOAT(QSmooth) PARAM_FLOAT_OPT(QHold, 0.0),
"Set quat smooth factor, number between 0 and 1, 1-> no smooth, 0-> no rotation<br/>QHold affect non move for small movements, QHold = 1, like 0, no holding, the smaller is QHold the less the rotation is affected",
{
FrmSmooth.Quat = QSmooth;
FrmSmooth.QuatHold = QHold;
})
DEFINE_SCRIPT(TRK_SmoothQuatModeSet,
CATEGORY(Tracking) PARAM_FLOAT(qMode),
"Set translation smooth factor, number between 0 and 1, 1-> no smooth, 0-> no move",
{
FrmQuatMode = qMode;
})
DEFINE_SCRIPT_REN(SCN_AnimLoad, AnimLoad,
CATEGORY(Small Scene) PARAM_STRING(AnimName) PARAM_STRING_OPT(Scene, "") PARAM_INT_OPT(ForceReload, 0),
"If anim does not exist, do nothing.",
{
RETURN_BOOL(LoadAnim(AnimName, Scene, ForceReload));
})
DEFINE_SCRIPT(SCN_AnimTime,
CATEGORY(Small Scene) PARAM_STRING(AnimName) PARAM_STRING_OPT(Scene, ""),
"Return anim time in milliseconds",
{
SmallScene *pSmallScene;
UnicID AnimID;
char DicoName[1024];
SmallScene_ANIM *pSmallSceneAnim;
pSmallSceneAnim = NULL;
pSmallScene = SmallNameToScene(Scene);
sprintf(DicoName, "%s_%s", Scene, AnimName);
AnimID = AnimDico.IsExist(DicoName);
if (AnimID == -1)
AnimID = AnimDico.IsExist(AnimName);
if (pSmallScene && (AnimID != -1))
{
pSmallSceneAnim = &pAllAnims[AnimDico.mpst_Dico[AnimID].AssociatedValue];
if (pSmallSceneAnim)
{ RETURN_INT(pSmallSceneAnim->TimeLineInMS*33); }
}
})
DEFINE_SCRIPT_REN(SCN_AnimPlay, AnimPlay,
CATEGORY(Small Scene) PARAM_STRING(SmscName) PARAM_STRING(AnimName) PARAM_INT_OPT(BaseTime,0) PARAM_FLOAT_OPT(PlayFactor,1),
"AnimPlay WILL return 1 if anim is finished.<br/>Basetime is the time (in MS) when anim has started.<br/> PlayFactor is the speed",
{
s32 DT = timeGetTime() - BaseTime;
DT *= PlayFactor;
RETURN_BOOL((BaseTime == 0 ) ||
PlayAnim(AnimName,SmscName,DT,1.0f));
})
DEFINE_SCRIPT(SCN_AnimPlayBlend,
CATEGORY(Small Scene) PARAM_STRING(SmscName) PARAM_STRING(AnimName) PARAM_FLOAT(BlendFactor) PARAM_INT_OPT(BaseTime,0) PARAM_FLOAT_OPT(PlayFactor,1),
"AnimPlay WILL return 1 if anim is finished.<br/>Basetime is the time (in MS) when anim has started.<br/> Blend is used for blending with existing position (1 is like playanim).",
{
s32 DT = timeGetTime() - BaseTime;
DT *= PlayFactor;
RETURN_BOOL((BaseTime == 0 ) ||
PlayAnim(AnimName,SmscName,DT,BlendFactor));
})
DEFINE_SCRIPT(SCN_AnimDestroy,
CATEGORY(Small Scene) PARAM_STRING(AnimName) PARAM_STRING_OPT(Scene, ""),
"Delete Anim",
{
DestroyAnim(AnimName, Scene);
})
DEFINE_SCRIPT_REN(PGEN_Load, PGenerator_Load,
CATEGORY(Particules generator) PARAM_STRING(Name) PARAM_STRING(GeneratorFileName) PARAM_STRING(SmallSceneName) PARAM_STRING_OPT(SceneObject,"") PARAM_STRING_OPT(MassTexture,""),
"Load particule generator",
{
SIZE grid;
int ID_Res;
grid.cx = 1;
grid.cy = 1;
ID_Res = LoadPGenerator(Name, GeneratorFileName, SmallSceneName, SceneObject,MassTexture);
if (ID_Res < 0)
sprintf(LuaErrors, "Error Creating Particule Generator");
})
DEFINE_SCRIPT(PGEN_Delete,
CATEGORY(Particules generator) PARAM_STRING(Name),
"Delete particule generator",
{
DeletePGenerator(Name);
})
DEFINE_SCRIPT(PGEN_Save,
CATEGORY(Particules generator) PARAM_STRING(Name) PARAM_STRING_OPT(newFilename, ""),
"save particule generator file",
{
SavePGenerator(Name, newFilename);
})
DEFINE_SCRIPT_REN(PGEN_Process, PGenerator_Process,
CATEGORY(Particules generator) PARAM_STRING(GeneratorName) PARAM_FLOAT_OPT(I_factor,0.0f) PARAM_FLOAT_OPT(J_factor,0.0f) PARAM_FLOAT_OPT(K_factor,0.0f) PARAM_INT_OPT(ProcessOnly, 0),
"if [Generator Name] = 'All', process all generators",
{
u32 PGeneratorIndex;
char GeneratorNameIn[2048];
strcpy(GeneratorNameIn, GeneratorName);
strlwr(GeneratorNameIn);
if (!(SkipFunctions & SKIP_PARTICLES))
{
if (strcmp(GeneratorNameIn, "all"))
{
if (GetPGeneratorFromString(GeneratorNameIn, &PGeneratorIndex))
ProcessParticules(ID_PGENERATOR[PGeneratorIndex], ProcessOnly, I_factor, J_factor, K_factor);
} else
{
for (int pGenIdx=0; pGenIdx<MAX_PGENERATOR; pGenIdx++)
{
if (!ID_PGENERATOR[pGenIdx]) continue;
ProcessParticules(ID_PGENERATOR[pGenIdx], ProcessOnly, I_factor, J_factor, K_factor);
}
}
}
})
DEFINE_SCRIPT(PGEN_Emit,
CATEGORY(Particules generator) PARAM_STRING(GeneratorName) PARAM_FLOAT_OPT(I_factor,0.0f) PARAM_FLOAT_OPT(J_factor,0.0f) PARAM_FLOAT_OPT(K_factor,0.0f) PARAM_INT_OPT(Life, 0),
"Emit a single particle and return it's index, the particle will have specified life in ms",
{
u32 PGeneratorIndex;
char GeneratorNameIn[2048];
strcpy(GeneratorNameIn, GeneratorName);
strlwr(GeneratorNameIn);
if (!(SkipFunctions & SKIP_PARTICLES))
{
if (strcmp(GeneratorNameIn, "all"))
{
if (GetPGeneratorFromString(GeneratorNameIn, &PGeneratorIndex))
RETURN_INT(EmitParticule(ID_PGENERATOR[PGeneratorIndex], Life, I_factor, J_factor, K_factor));
} else
{
for (int pGenIdx=0; pGenIdx<MAX_PGENERATOR; pGenIdx++)
{
if (!ID_PGENERATOR[pGenIdx]) continue;
EmitParticule(ID_PGENERATOR[pGenIdx], Life, I_factor, J_factor, K_factor);
}
}
}
})
DEFINE_SCRIPT(PGEN_EmitFromPos,
CATEGORY(Particules generator) PARAM_STRING(GeneratorName) PARAM_VECTOR(AbsoluteOrigin) PARAM_VECTOR(AbsoluteDirection) PARAM_INT_OPT(Life, 0),
"Emit a single particle at the specified position and direction and return it's index",
{
u32 PGeneratorIndex;
char GeneratorNameIn[2048];
strcpy(GeneratorNameIn, GeneratorName);
strlwr(GeneratorNameIn);
if (!(SkipFunctions & SKIP_PARTICLES))
{
if (strcmp(GeneratorNameIn, "all"))
{
if (GetPGeneratorFromString(GeneratorNameIn, &PGeneratorIndex))
RETURN_INT(EmitParticule(ID_PGENERATOR[PGeneratorIndex], Life, 0.0, 0.0, 0.0, &AbsoluteOrigin, &AbsoluteDirection));
} else
{
for (int pGenIdx=0; pGenIdx<MAX_PGENERATOR; pGenIdx++)
{
if (!ID_PGENERATOR[pGenIdx]) continue;
EmitParticule(ID_PGENERATOR[pGenIdx], Life, 0.0, 0.0, 0.0, &AbsoluteOrigin, &AbsoluteDirection);
}
}
}
})
DEFINE_SCRIPT_REN(PGEN_Render, PGenerator_Render,
CATEGORY(Particules generator) PARAM_STRING(GeneratorName) PARAM_STRING_OPT(SmallSceneName,""),
"if [Generator Name] = 'All', process all generators",
{
u32 PGeneratorIndex;
char GeneratorNameIn[2048];
strcpy(GeneratorNameIn, GeneratorName);
strlwr(GeneratorNameIn);
if (!(SkipFunctions & SKIP_PARTICLES))
{
if (strcmp(GeneratorNameIn, "all"))
{
if (GetPGeneratorFromString(GeneratorNameIn, &PGeneratorIndex))
RenderParticules(ID_PGENERATOR[PGeneratorIndex], SmallSceneName);
} else
{
for (int pGenIdx=0; pGenIdx<MAX_PGENERATOR; pGenIdx++)
{
if (!ID_PGENERATOR[pGenIdx]) continue;
RenderParticules(ID_PGENERATOR[pGenIdx], SmallSceneName);
}
}
}
})
DEFINE_SCRIPT(PGEN_Restart,
CATEGORY(Particules generator) PARAM_STRING(GeneratorName) PARAM_INT_OPT(forceReinit, 0),
"if [Generator Name] = 'All', restart all generators",
{
u32 PGeneratorIndex;
char GeneratorNameIn[2048];
strcpy(GeneratorNameIn, GeneratorName);
strlwr(GeneratorNameIn);
if (!(SkipFunctions & SKIP_PARTICLES))
{
if (strcmp(GeneratorNameIn, "all"))
{
if (GetPGeneratorFromString(GeneratorNameIn, &PGeneratorIndex))
{
if (!forceReinit)
{
memset( ID_PGENERATOR[PGeneratorIndex]->particulesTab, 0,
ID_PGENERATOR[PGeneratorIndex]->maxParticules*sizeof(Particules));
ID_PGENERATOR[PGeneratorIndex]->nbParticules = 0;
ID_PGENERATOR[PGeneratorIndex]->curParticule = -1;
} else
{
ID_PGENERATOR[PGeneratorIndex]->Init();
ComputeParticleOptions(ID_PGENERATOR[PGeneratorIndex]);
}
}
} else
{
for (int pGenIdx=0; pGenIdx<MAX_PGENERATOR; pGenIdx++)
{
if (!ID_PGENERATOR[pGenIdx]) continue;
if (!forceReinit)
{
memset( ID_PGENERATOR[pGenIdx]->particulesTab, 0,
ID_PGENERATOR[pGenIdx]->maxParticules*sizeof(Particules));
ID_PGENERATOR[pGenIdx]->nbParticules = 0;
ID_PGENERATOR[pGenIdx]->curParticule = -1;
} else
{
ID_PGENERATOR[pGenIdx]->Init();
ComputeParticleOptions(ID_PGENERATOR[pGenIdx]);
}
}
}
}
})
DEFINE_SCRIPT(PGEN_ParticlePosGet,
CATEGORY(Particules generator) PARAM_STRING(GeneratorName) PARAM_INT(Index),
"Get Particle position",
{
u32 PGeneratorIndex;
if (!(SkipFunctions & SKIP_PARTICLES))
{
if (GetPGeneratorFromString(GeneratorName, &PGeneratorIndex))
{
if (Index < ID_PGENERATOR[PGeneratorIndex]->nbParticules &&
ID_PGENERATOR[PGeneratorIndex]->particulesTab[Index].alive)
{
RETURN_VECTOR(&ID_PGENERATOR[PGeneratorIndex]->particulesTab[Index].coordsDest);
}
}
}
})
DEFINE_SCRIPT(PGEN_ParticlePosSet,
CATEGORY(Particules generator) PARAM_STRING(GeneratorName) PARAM_INT(Index) PARAM_VECTOR(coords) PARAM_INT_OPT(inSource, 0),
"Get Particle position",
{
u32 PGeneratorIndex;
if (!(SkipFunctions & SKIP_PARTICLES))
{
if (GetPGeneratorFromString(GeneratorName, &PGeneratorIndex))
{
if (Index < ID_PGENERATOR[PGeneratorIndex]->nbParticules &&
ID_PGENERATOR[PGeneratorIndex]->particulesTab[Index].alive)
{
if (inSource)
ID_PGENERATOR[PGeneratorIndex]->particulesTab[Index].coords = coords;
else
ID_PGENERATOR[PGeneratorIndex]->particulesTab[Index].coordsDest = coords;
}
}
}
})
DEFINE_SCRIPT(PGEN_ParticleSpeedGet,
CATEGORY(Particules generator) PARAM_STRING(GeneratorName) PARAM_INT(Index),
"Get Particle position",
{
u32 PGeneratorIndex;
if (!(SkipFunctions & SKIP_PARTICLES))
{
if (GetPGeneratorFromString(GeneratorName, &PGeneratorIndex))
{
if (Index < ID_PGENERATOR[PGeneratorIndex]->nbParticules &&
ID_PGENERATOR[PGeneratorIndex]->particulesTab[Index].alive)
{
RETURN_VECTOR(&ID_PGENERATOR[PGeneratorIndex]->particulesTab[Index].speedDest);
}
}
}
})
DEFINE_SCRIPT(PGEN_ParticleSpeedSet,
CATEGORY(Particules generator) PARAM_STRING(GeneratorName) PARAM_INT(Index) PARAM_VECTOR(speed) PARAM_INT_OPT(inSource, 0),
"Get Particle position",
{
u32 PGeneratorIndex;
if (!(SkipFunctions & SKIP_PARTICLES))
{
if (GetPGeneratorFromString(GeneratorName, &PGeneratorIndex))
{
if (Index < ID_PGENERATOR[PGeneratorIndex]->nbParticules &&
ID_PGENERATOR[PGeneratorIndex]->particulesTab[Index].alive)
{
if (inSource)
ID_PGENERATOR[PGeneratorIndex]->particulesTab[Index].speed = speed;
else
ID_PGENERATOR[PGeneratorIndex]->particulesTab[Index].speedDest = speed;
}
}
}
})
DEFINE_SCRIPT(PGEN_ParticleCollideCallbackAdd,
CATEGORY(Particules generator) PARAM_STRING(GeneratorName) PARAM_INT(Index) PARAM_STRING(CallbackName),
"Add callback to specific particle when collide, Callback type:<br/> MyCallback(SceneName, ObjectName, AbsolutePos, AbsoluteNormal, UV)",
{
u32 PGeneratorIndex;
if (!(SkipFunctions & SKIP_PARTICLES))
{
if (GetPGeneratorFromString(GeneratorName, &PGeneratorIndex))
{
if (Index < ID_PGENERATOR[PGeneratorIndex]->maxParticules)
{
if (ID_PGENERATOR[PGeneratorIndex]->particulesTab[Index].luaCollideCallBack)
{
CC_free(ID_PGENERATOR[PGeneratorIndex]->particulesTab[Index].luaCollideCallBack);
ID_PGENERATOR[PGeneratorIndex]->particulesTab[Index].luaCollideCallBack = NULL;
}
ID_PGENERATOR[PGeneratorIndex]->particulesTab[Index].luaCollideCallBack = (char *)CC_malloc(strlen(CallbackName)+1);
strcpy(ID_PGENERATOR[PGeneratorIndex]->particulesTab[Index].luaCollideCallBack, CallbackName);
}
}
}
})
DEFINE_SCRIPT(PGEN_ParticleAliveTest,
CATEGORY(Particules generator) PARAM_STRING(GeneratorName) PARAM_INT(Index),
"Verify if particle is alive",
{
u32 PGeneratorIndex;
if (!(SkipFunctions & SKIP_PARTICLES))
{
if (GetPGeneratorFromString(GeneratorName, &PGeneratorIndex))
{
if (Index < ID_PGENERATOR[PGeneratorIndex]->nbParticules)
{
RETURN_BOOL(ID_PGENERATOR[PGeneratorIndex]->particulesTab[Index].alive)
}
}
}
})
DEFINE_SCRIPT(PGEN_ParticleKill,
CATEGORY(Particules generator) PARAM_STRING(GeneratorName) PARAM_INT(Index),
"Kill selected Particle, if -1 kills all living particles, if -2 kill all livings particles and stop generation (if no repeat)",
{
u32 PGeneratorIndex;
char GeneratorNameIn[2048];
strcpy(GeneratorNameIn, GeneratorName);
strlwr(GeneratorNameIn);
if (!(SkipFunctions & SKIP_PARTICLES))
{
if (strcmp(GeneratorNameIn, "all"))
{
if (GetPGeneratorFromString(GeneratorNameIn, &PGeneratorIndex))
{
if (Index >= 0)
{
ID_PGENERATOR[PGeneratorIndex]->particulesTab[Index].alive = 0;
} else
{
for (int i=0; i<ID_PGENERATOR[PGeneratorIndex]->maxParticules; i++)
{
ID_PGENERATOR[PGeneratorIndex]->particulesTab[i].alive = 0;
}
if (Index < -1)
{
ID_PGENERATOR[PGeneratorIndex]->nbParticules = ID_PGENERATOR[PGeneratorIndex]->maxParticules;
}
}
}
} else
{
for (int pGenIdx=0; pGenIdx<MAX_PGENERATOR; pGenIdx++)
{
if (!ID_PGENERATOR[pGenIdx]) continue;
if (Index >= 0)
{
ID_PGENERATOR[pGenIdx]->particulesTab[Index].alive = 0;
} else
{
for (int i=0; i<ID_PGENERATOR[pGenIdx]->maxParticules; i++)
{
ID_PGENERATOR[pGenIdx]->particulesTab[i].alive = 0;
}
if (Index < -1)
{
ID_PGENERATOR[pGenIdx]->nbParticules = ID_PGENERATOR[pGenIdx]->maxParticules;
}
}
}
}
}
})
DEFINE_SCRIPT(PGEN_RepeatSet,
CATEGORY(Particules generator) PARAM_STRING(GeneratorName) PARAM_INT(ON_OFF),
"Set or Remove particle repeat mode",
{
u32 PGeneratorIndex;
char GeneratorNameIn[2048];
strcpy(GeneratorNameIn, GeneratorName);
strlwr(GeneratorNameIn);
if (!(SkipFunctions & SKIP_PARTICLES))
{
if (strcmp(GeneratorName, "all"))
{
if (GetPGeneratorFromString(GeneratorNameIn, &PGeneratorIndex))
{
ID_PGENERATOR[PGeneratorIndex]->particuleRepeat = ON_OFF;
}
} else
{
for (int pGenIdx=0; pGenIdx<MAX_PGENERATOR; pGenIdx++)
{
ID_PGENERATOR[pGenIdx]->particuleRepeat = ON_OFF;
}
}
}
})
DEFINE_SCRIPT(PGEN_CONF_OptionsSet,
CATEGORY(Particules generator config) PARAM_PGENERATOR(Pgen) PARAM_INT(Value),
"Set Particules generator config Options",
{
Pgen->options = Value;
})
DEFINE_SCRIPT(PGEN_CONF_OptionsGet,
CATEGORY(Particules generator config) PARAM_PGENERATOR(Pgen),
"Get Particules generator config Options",
{
RETURN_INT(Pgen->options);
})
DEFINE_SCRIPT(PGEN_CONF_TextureGridSet,
CATEGORY(Particules generator config) PARAM_PGENERATOR(Pgen) PARAM_INT(Value1) PARAM_INT(Value2),
"Set Particules generator config Texture Grid",
{
Pgen->TextureGrid.cx = Value1;
Pgen->TextureGrid.cy = Value2;
})
DEFINE_SCRIPT(PGEN_CONF_TextureGridGet,
CATEGORY(Particules generator config) PARAM_PGENERATOR(Pgen),
"Get Particules generator config Texture Grid",
{
RETURN_INT(Pgen->TextureGrid.cx);
RETURN_INT(Pgen->TextureGrid.cy);
})
DEFINE_SCRIPT(PGEN_CONF_BlendModeSet,
CATEGORY(Particules generator config) PARAM_PGENERATOR(Pgen) PARAM_INT(Value),
"Set Particules generator config Blend Mode",
{
Pgen->BlendMode = Value;
})
DEFINE_SCRIPT(PGEN_CONF_BlendModeGet,
CATEGORY(Particules generator config) PARAM_PGENERATOR(Pgen),
"Get Particules generator config Blend Mode",
{
RETURN_INT(Pgen->BlendMode);
})
DEFINE_SCRIPT(PGEN_CONF_AlphaThresholdSet,
CATEGORY(Particules generator config) PARAM_PGENERATOR(Pgen) PARAM_INT(Value),
"Set Particules generator config Alpha Threshold",
{
Pgen->AlphaThreshold = Value;
})
DEFINE_SCRIPT(PGEN_CONF_AlphaThresholdGet,
CATEGORY(Particules generator config) PARAM_PGENERATOR(Pgen),
"Get Particules generator config Alpha Threshold",
{
RETURN_INT(Pgen->AlphaThreshold);
})
DEFINE_SCRIPT(PGEN_CONF_ParticuleNumberSet,
CATEGORY(Particules generator config) PARAM_PGENERATOR(Pgen) PARAM_INT(Value),
"Set Particules total number",
{
Pgen->maxParticules = Value;
if (Pgen->particulesTab)
Pgen->particulesTab = (Particules *)CC_realloc(Pgen->particulesTab, Value*sizeof(Particules));
else
Pgen->particulesTab = (Particules *)CC_malloc(Value*sizeof(Particules));
})
DEFINE_SCRIPT(PGEN_CONF_ParticuleNumberGet,
CATEGORY(Particules generator config) PARAM_PGENERATOR(Pgen),
"Get Particules total number",
{
RETURN_INT(Pgen->maxParticules);
})
DEFINE_SCRIPT(PGEN_CONF_ParticuleLifeSet,
CATEGORY(Particules generator config) PARAM_PGENERATOR(Pgen) PARAM_INT(Value),
"Set Particules life in ms",
{
Pgen->particuleLife = Value;
})
DEFINE_SCRIPT(PGEN_CONF_ParticuleLifeGet,
CATEGORY(Particules generator config) PARAM_PGENERATOR(Pgen),
"Get Particules life in ms",
{
RETURN_INT(Pgen->particuleLife);
})
DEFINE_SCRIPT(PGEN_CONF_ParticuleRepeatSet,
CATEGORY(Particules generator config) PARAM_PGENERATOR(Pgen) PARAM_INT(Value),
"Set Particules life in ms",
{
Pgen->particuleRepeat = Value;
})
DEFINE_SCRIPT(PGEN_CONF_ParticuleRepeatGet,
CATEGORY(Particules generator config) PARAM_PGENERATOR(Pgen),
"Get Particules life in ms",
{
RETURN_INT(Pgen->particuleRepeat);
})
DEFINE_SCRIPT(PGEN_CONF_ParticuleLifeRandSet,
CATEGORY(Particules generator config) PARAM_PGENERATOR(Pgen) PARAM_FLOAT(Value),
"Set Particules life random",
{
Pgen->particuleLifeRand = Value;
})
DEFINE_SCRIPT(PGEN_CONF_ParticuleLifeRandGet,
CATEGORY(Particules generator config) PARAM_PGENERATOR(Pgen),
"Get Particules life random",
{
RETURN_FLOAT(Pgen->particuleLifeRand);
})
DEFINE_SCRIPT(PGEN_CONF_GenSpeedSet,
CATEGORY(Particules generator config) PARAM_PGENERATOR(Pgen) PARAM_FLOAT(Value),
"Set Particules generator config generation speed",
{
Pgen->genSpeed = Value;
})
DEFINE_SCRIPT(PGEN_CONF_GenSpeedGet,
CATEGORY(Particules generator config) PARAM_PGENERATOR(Pgen),
"Get Particules generator config generation speed",
{
RETURN_FLOAT(Pgen->genSpeed);
})
DEFINE_SCRIPT(PGEN_CONF_GenSpeedRandSet,
CATEGORY(Particules generator config) PARAM_PGENERATOR(Pgen) PARAM_FLOAT(Value),
"Set Particules generator config generation speed random",
{
Pgen->genSpeedRand = Value;
})
DEFINE_SCRIPT(PGEN_CONF_GenSpeedRandGet,
CATEGORY(Particules generator config) PARAM_PGENERATOR(Pgen),
"Get Particules generator config generation speed random",
{
RETURN_FLOAT(Pgen->genSpeedRand);
})
DEFINE_SCRIPT(PGEN_CONF_GenAngleAllowedSet,
CATEGORY(Particules generator config) PARAM_PGENERATOR(Pgen) PARAM_FLOAT(Value),
"Set Particules generator config generation angle",
{
Pgen->genAngleAllowed = Value;
})
DEFINE_SCRIPT(PGEN_CONF_GenAngleAllowedGet,
CATEGORY(Particules generator config) PARAM_PGENERATOR(Pgen),
"Get Particules generator config generation angle",
{
RETURN_FLOAT(Pgen->genAngleAllowed);
})
DEFINE_SCRIPT(PGEN_CONF_GenPowerSet,
CATEGORY(Particules generator config) PARAM_PGENERATOR(Pgen) PARAM_FLOAT(Value),
"Set Particules generator config generation power",
{
Pgen->genPower = Value;
})
DEFINE_SCRIPT(PGEN_CONF_GenPowerGet,
CATEGORY(Particules generator config) PARAM_PGENERATOR(Pgen),
"Get Particules generator config generation power",
{
RETURN_FLOAT(Pgen->genPower);
})
DEFINE_SCRIPT(PGEN_CONF_GenPowerRandSet,
CATEGORY(Particules generator config) PARAM_PGENERATOR(Pgen) PARAM_FLOAT(Value),
"Set Particules generator config generation power random",
{
Pgen->genPowerRand = Value;
})
DEFINE_SCRIPT(PGEN_CONF_GenPowerRandGet,
CATEGORY(Particules generator config) PARAM_PGENERATOR(Pgen),
"Get Particules generator config generation power random",
{
RETURN_FLOAT(Pgen->genPowerRand);
})
DEFINE_SCRIPT(PGEN_CONF_GenWidthSet,
CATEGORY(Particules generator config) PARAM_PGENERATOR(Pgen) PARAM_FLOAT(Value),
"Set Particules generator config generation width",
{
Pgen->genWidth = Value;
})
DEFINE_SCRIPT(PGEN_CONF_GenWidthGet,
CATEGORY(Particules generator config) PARAM_PGENERATOR(Pgen),
"Get Particules generator config generation width",
{
RETURN_FLOAT(Pgen->genWidth);
})
DEFINE_SCRIPT(PGEN_CONF_GenHeightSet,
CATEGORY(Particules generator config) PARAM_PGENERATOR(Pgen) PARAM_FLOAT(Value),
"Set Particules generator config generation height",
{
Pgen->genHeight = Value;
})
DEFINE_SCRIPT(PGEN_CONF_GenHeightGet,
CATEGORY(Particules generator config) PARAM_PGENERATOR(Pgen),
"Get Particules generator config generation height",
{
RETURN_FLOAT(Pgen->genHeight);
})
DEFINE_SCRIPT(PGEN_CONF_GenSizeRandSet,
CATEGORY(Particules generator config) PARAM_PGENERATOR(Pgen) PARAM_FLOAT(Value),
"Set Particules generator config random size",
{
Pgen->genSizeRand = Value;
})
DEFINE_SCRIPT(PGEN_CONF_GenSizeRandGet,
CATEGORY(Particules generator config) PARAM_PGENERATOR(Pgen),
"Get Particules generator config random size",
{
RETURN_FLOAT(Pgen->genSizeRand);
})
DEFINE_SCRIPT(PGEN_CONF_GenNumberSet,
CATEGORY(Particules generator config) PARAM_PGENERATOR(Pgen) PARAM_INT(Value),
"Set Particules generator config generation number",
{
Pgen->genNumber = Value;
})
DEFINE_SCRIPT(PGEN_CONF_GenNumberGet,
CATEGORY(Particules generator config) PARAM_PGENERATOR(Pgen),
"Get Particules generator config generation number",
{
RETURN_INT(Pgen->genNumber);
})
DEFINE_SCRIPT(PGEN_CONF_GravitySet,
CATEGORY(Particules generator config) PARAM_PGENERATOR(Pgen) PARAM_VECTOR(Value),
"Set Particules generator config Gravity",
{
Pgen->forces.Gravity = Value;
})
DEFINE_SCRIPT(PGEN_CONF_GravityGet,
CATEGORY(Particules generator config) PARAM_PGENERATOR(Pgen),
"Get Particules generator config Gravity",
{
RETURN_VECTOR(&Pgen->forces.Gravity);
})
DEFINE_SCRIPT(PGEN_CONF_FrictionsSet,
CATEGORY(Particules generator config) PARAM_PGENERATOR(Pgen) PARAM_FLOAT(Value),
"Set Particules generator config Frictions",
{
Pgen->forces.Frictions = Value;
})
DEFINE_SCRIPT(PGEN_CONF_FrictionsGet,
CATEGORY(Particules generator config) PARAM_PGENERATOR(Pgen),
"Get Particules generator config Frictions",
{
RETURN_FLOAT(Pgen->forces.Frictions);
})
DEFINE_SCRIPT(PGEN_CONF_WindDirectionSet,
CATEGORY(Particules generator config) PARAM_PGENERATOR(Pgen) PARAM_VECTOR(Value),
"Set Particules generator config Wind Direction",
{
Pgen->forces.WindDirection = Value;
})
DEFINE_SCRIPT(PGEN_CONF_WindDirectionGet,
CATEGORY(Particules generator config) PARAM_PGENERATOR(Pgen),
"Get Particules generator config Wind Direction",
{
RETURN_VECTOR(&Pgen->forces.WindDirection);
})
DEFINE_SCRIPT(PGEN_CONF_WindForceSet,
CATEGORY(Particules generator config) PARAM_PGENERATOR(Pgen) PARAM_FLOAT(Value),
"Set Particules generator config Wind Force",
{
Pgen->forces.WindForce = Value;
})
DEFINE_SCRIPT(PGEN_CONF_WindForceGet,
CATEGORY(Particules generator config) PARAM_PGENERATOR(Pgen),
"Get Particules generator config Wind Force",
{
RETURN_FLOAT(Pgen->forces.WindForce);
})
DEFINE_SCRIPT(PGEN_CONF_RotationSpeedSet,
CATEGORY(Particules generator config) PARAM_PGENERATOR(Pgen) PARAM_FLOAT(Value),
"Set Particules generator config Rotation Speed",
{
Pgen->forces.RotationSpeed = Value;
})
DEFINE_SCRIPT(PGEN_CONF_RotationSpeedGet,
CATEGORY(Particules generator config) PARAM_PGENERATOR(Pgen),
"Get Particules generator config Rotation Speed",
{
RETURN_FLOAT(Pgen->forces.RotationSpeed);
})
DEFINE_SCRIPT(PGEN_CONF_RotationRandSet,
CATEGORY(Particules generator config) PARAM_PGENERATOR(Pgen) PARAM_FLOAT(Value),
"Set Particules generator config Rotation Random",
{
Pgen->forces.RotationRand = Value;
})
DEFINE_SCRIPT(PGEN_CONF_RotationRandGet,
CATEGORY(Particules generator config) PARAM_PGENERATOR(Pgen),
"Get Particules generator config Rotation Random",
{
RETURN_FLOAT(Pgen->forces.RotationRand);
})
DEFINE_SCRIPT(PGEN_CONF_RotationInitSet,
CATEGORY(Particules generator config) PARAM_PGENERATOR(Pgen) PARAM_FLOAT(Value1) PARAM_FLOAT(Value2),
"Set Particules generator config ",
{
Pgen->forces.RotationInit = Value1;
Pgen->forces.RotationInit2 = Value2;
})
DEFINE_SCRIPT(PGEN_CONF_RotationInitGet,
CATEGORY(Particules generator config) PARAM_PGENERATOR(Pgen),
"Get Particules generator config ",
{
RETURN_FLOAT(Pgen->forces.RotationInit);
RETURN_FLOAT(Pgen->forces.RotationInit2);
})
DEFINE_SCRIPT(PGEN_CONF_GrowForTimeSet,
CATEGORY(Particules generator config) PARAM_PGENERATOR(Pgen) PARAM_INT(Value),
"Set Particules generator config Grow For Time",
{
Pgen->forces.GrowFor = Value;
})
DEFINE_SCRIPT(PGEN_CONF_GrowForTimeGet,
CATEGORY(Particules generator config) PARAM_PGENERATOR(Pgen),
"Get Particules generator config Grow For Time",
{
RETURN_INT(Pgen->forces.GrowFor);
})
DEFINE_SCRIPT(PGEN_CONF_GrowForInitSet,
CATEGORY(Particules generator config) PARAM_PGENERATOR(Pgen) PARAM_FLOAT(Value),
"Set Particules generator config Grow For Init",
{
Pgen->forces.GrowForInit = Value;
})
DEFINE_SCRIPT(PGEN_CONF_GrowForInitGet,
CATEGORY(Particules generator config) PARAM_PGENERATOR(Pgen),
"Get Particules generator config Grow For Init",
{
RETURN_FLOAT(Pgen->forces.GrowForInit);
})
DEFINE_SCRIPT(PGEN_CONF_GrowForEndSet,
CATEGORY(Particules generator config) PARAM_PGENERATOR(Pgen) PARAM_FLOAT(Value),
"Set Particules generator config Grow For End",
{
Pgen->forces.GrowForEnd = Value;
})
DEFINE_SCRIPT(PGEN_CONF_GrowForEndGet,
CATEGORY(Particules generator config) PARAM_PGENERATOR(Pgen),
"Get Particules generator config Grow For End",
{
RETURN_FLOAT(Pgen->forces.GrowForEnd);
})
DEFINE_SCRIPT(PGEN_CONF_GrowForTimeRandSet,
CATEGORY(Particules generator config) PARAM_PGENERATOR(Pgen) PARAM_FLOAT(Value),
"Set Particules generator config Grow For Time Random",
{
Pgen->forces.GrowForRand = Value;
})
DEFINE_SCRIPT(PGEN_CONF_GrowForTimeRandGet,
CATEGORY(Particules generator config) PARAM_PGENERATOR(Pgen),
"Get Particules generator config Grow For Time Random",
{
RETURN_FLOAT(Pgen->forces.GrowForRand);
})
DEFINE_SCRIPT(PGEN_CONF_FadeForTimeSet,
CATEGORY(Particules generator config) PARAM_PGENERATOR(Pgen) PARAM_INT(Value),
"Set Particules generator config Fade For Time",
{
Pgen->forces.FadeFor = Value;
})
DEFINE_SCRIPT(PGEN_CONF_FadeForTimeGet,
CATEGORY(Particules generator config) PARAM_PGENERATOR(Pgen),
"Get Particules generator config Fade For Time",
{
RETURN_INT(Pgen->forces.FadeFor);
})
DEFINE_SCRIPT(PGEN_CONF_FadeForInitSet,
CATEGORY(Particules generator config) PARAM_PGENERATOR(Pgen) PARAM_FLOAT(Value),
"Set Particules generator config Fade For Init",
{
Pgen->forces.FadeForInit = Value;
})
DEFINE_SCRIPT(PGEN_CONF_FadeForInitGet,
CATEGORY(Particules generator config) PARAM_PGENERATOR(Pgen),
"Get Particules generator config Fade For Init",
{
RETURN_FLOAT(Pgen->forces.FadeForInit);
})
DEFINE_SCRIPT(PGEN_CONF_FadeForEndSet,
CATEGORY(Particules generator config) PARAM_PGENERATOR(Pgen) PARAM_FLOAT(Value),
"Set Particules generator config Fade For End",
{
Pgen->forces.FadeForEnd = Value;
})
DEFINE_SCRIPT(PGEN_CONF_FadeForEndGet,
CATEGORY(Particules generator config) PARAM_PGENERATOR(Pgen),
"Get Particules generator config Fade For End",
{
RETURN_FLOAT(Pgen->forces.FadeForEnd);
})
DEFINE_SCRIPT(PGEN_CONF_FadeForTimeRandSet,
CATEGORY(Particules generator config) PARAM_PGENERATOR(Pgen) PARAM_FLOAT(Value),
"Set Particules generator config Fade For Time Random",
{
Pgen->forces.FadeForRand = Value;
})
DEFINE_SCRIPT(PGEN_CONF_FadeForTimeRandGet,
CATEGORY(Particules generator config) PARAM_PGENERATOR(Pgen),
"Get Particules generator config Fade For Time Random",
{
RETURN_FLOAT(Pgen->forces.FadeForRand);
})
DEFINE_SCRIPT(PGEN_CONF_GrowForColorTimeSet,
CATEGORY(Particules generator config) PARAM_PGENERATOR(Pgen) PARAM_INT(Value),
"Set Particules generator config Grow For Color Time",
{
Pgen->forces.GrowForColor = Value;
})
DEFINE_SCRIPT(PGEN_CONF_GrowForColorTimeGet,
CATEGORY(Particules generator config) PARAM_PGENERATOR(Pgen),
"Get Particules generator config Grow For Color Time",
{
RETURN_INT(Pgen->forces.GrowForColor);
})
DEFINE_SCRIPT(PGEN_CONF_GrowForColorInitSet,
CATEGORY(Particules generator config) PARAM_PGENERATOR(Pgen) PARAM_COLOR(Value),
"Set Particules generator config Grow For Color Init",
{
Value = ARGB2ABGR(Value);
Pgen->forces.GrowForColorInit = Value;
})
DEFINE_SCRIPT(PGEN_CONF_GrowForColorInitGet,
CATEGORY(Particules generator config) PARAM_PGENERATOR(Pgen),
"Get Particules generator config Grow For Color Init",
{
RETURN_COLOR(Pgen->forces.GrowForColorInit);
})
DEFINE_SCRIPT(PGEN_CONF_GrowForColorEndSet,
CATEGORY(Particules generator config) PARAM_PGENERATOR(Pgen) PARAM_COLOR(Value),
"Set Particules generator config Grow For Color End",
{
Value = ARGB2ABGR(Value);
Pgen->forces.GrowForColorEnd = Value;
})
DEFINE_SCRIPT(PGEN_CONF_GrowForColorEndGet,
CATEGORY(Particules generator config) PARAM_PGENERATOR(Pgen),
"Get Particules generator config Grow For Color End",
{
RETURN_COLOR(Pgen->forces.GrowForColorEnd);
})
DEFINE_SCRIPT(PGEN_CONF_FadeForColorTimeSet,
CATEGORY(Particules generator config) PARAM_PGENERATOR(Pgen) PARAM_INT(Value),
"Set Particules generator config Fade For Color Time",
{
Pgen->forces.FadeForColor = Value;
})
DEFINE_SCRIPT(PGEN_CONF_FadeForColorTimeGet,
CATEGORY(Particules generator config) PARAM_PGENERATOR(Pgen),
"Get Particules generator config Fade For Color Time",
{
RETURN_INT(Pgen->forces.FadeForColor);
})
DEFINE_SCRIPT(PGEN_CONF_FadeForColorInitSet,
CATEGORY(Particules generator config) PARAM_PGENERATOR(Pgen) PARAM_COLOR(Value),
"Set Particules generator config Fade For Color Init",
{
Value = ARGB2ABGR(Value);
Pgen->forces.FadeForColorInit = Value;
})
DEFINE_SCRIPT(PGEN_CONF_FadeForColorInitGet,
CATEGORY(Particules generator config) PARAM_PGENERATOR(Pgen),
"Get Particules generator config Fade For Color Init",
{
RETURN_COLOR(Pgen->forces.FadeForColorInit);
})
DEFINE_SCRIPT(PGEN_CONF_FadeForColorEndSet,
CATEGORY(Particules generator config) PARAM_PGENERATOR(Pgen) PARAM_COLOR(Value),
"Set Particules generator config Fade For Color End",
{
Value = ARGB2ABGR(Value);
Pgen->forces.FadeForColorEnd = Value;
})
DEFINE_SCRIPT(PGEN_CONF_FadeForColorEndGet,
CATEGORY(Particules generator config) PARAM_PGENERATOR(Pgen),
"Get Particules generator config Fade For Color End",
{
RETURN_COLOR(Pgen->forces.FadeForColorEnd);
})
DEFINE_SCRIPT(PGEN_CONF_AnimSpeedSet,
CATEGORY(Particules generator config) PARAM_PGENERATOR(Pgen) PARAM_INT(Value),
"Set Particules generator config Anim Speed",
{
Pgen->forces.AnimSpeed = Value;
})
DEFINE_SCRIPT(PGEN_CONF_AnimSpeedGet,
CATEGORY(Particules generator config) PARAM_PGENERATOR(Pgen),
"Get Particules generator config Anim Speed",
{
RETURN_INT(Pgen->forces.AnimSpeed);
})
DEFINE_SCRIPT(PGEN_CONF_AnimRepeatSet,
CATEGORY(Particules generator config) PARAM_PGENERATOR(Pgen) PARAM_INT(Value),
"Set Particules generator config Anim Repeat",
{
Pgen->forces.AnimRepeat = Value;
})
DEFINE_SCRIPT(PGEN_CONF_AnimRepeatGet,
CATEGORY(Particules generator config) PARAM_PGENERATOR(Pgen),
"Get Particules generator config Anim Repeat",
{
RETURN_INT(Pgen->forces.AnimRepeat);
})
DEFINE_SCRIPT(PGEN_CONF_AnimInitSet,
CATEGORY(Particules generator config) PARAM_PGENERATOR(Pgen) PARAM_INT(Value),
"Set Particules generator config AnimInit",
{
Pgen->forces.AnimInit = Value;
})
DEFINE_SCRIPT(PGEN_CONF_AnimInitGet,
CATEGORY(Particules generator config) PARAM_PGENERATOR(Pgen),
"Get Particules generator config AnimInit",
{
RETURN_INT(Pgen->forces.AnimInit);
})
DEFINE_SCRIPT(PGEN_CONF_CollisionFrictionSet,
CATEGORY(Particules generator config) PARAM_PGENERATOR(Pgen) PARAM_FLOAT(Value),
"Set Particules generator config collision Friction",
{
Pgen->forces.collisionFriction = Value;
})
DEFINE_SCRIPT(PGEN_CONF_CollisionFrictionGet,
CATEGORY(Particules generator config) PARAM_PGENERATOR(Pgen),
"Get Particules generator config collision Friction",
{
RETURN_FLOAT(Pgen->forces.collisionFriction);
})
DEFINE_SCRIPT(PGEN_CONF_CollisionRandAngleSet,
CATEGORY(Particules generator config) PARAM_PGENERATOR(Pgen) PARAM_FLOAT(Value),
"Set Particules generator config collision Random Angle",
{
Pgen->forces.collisionRandAngle = Value;
})
DEFINE_SCRIPT(PGEN_CONF_CollisionRandAngleGet,
CATEGORY(Particules generator config) PARAM_PGENERATOR(Pgen),
"Get Particules generator config collision Random Angle",
{
RETURN_FLOAT(Pgen->forces.collisionRandAngle);
})
DEFINE_SCRIPT(APP_ApplicationPathGet,
CATEGORY(Application),
"Get the application path",
{
int nArgs;
LPWSTR *szArglist = CommandLineToArgvW(GetCommandLineW(), &nArgs);
size_t size = wcslen(szArglist[0])+1;
char* exepathname = (char*)ZeroAlloc(size);
wcstombs(exepathname, szArglist[0], size);
RETURN_STRING(exepathname);
})
DEFINE_SCRIPT(PGEN_MediaGet,
CATEGORY(Particules generator) PARAM_STRING(GeneratorName),
"Set or Remove particle media",
{
u32 PGeneratorIndex;
if (GetPGeneratorFromString(GeneratorName, &PGeneratorIndex))
{
RETURN_STRING(ID_PGENERATOR[PGeneratorIndex]->MediaName);
}
})
DEFINE_SCRIPT(PGEN_MediaSet,
CATEGORY(Particules generator) PARAM_STRING(GeneratorName) PARAM_STRING(media),
"Set or Remove particle media",
{
u32 PGeneratorIndex;
u32 PMediaIndex;
if (GetPGeneratorFromString(GeneratorName, &PGeneratorIndex))
{
if (GetMediaFromString(ID_PGENERATOR[PGeneratorIndex]->MediaName, &PMediaIndex))
DestroyMedia(PMediaIndex);
CreateMedia(media, 0);
strcpy(ID_PGENERATOR[PGeneratorIndex]->MediaName, media);
}
})
DEFINE_SCRIPT(PGEN_MassTextureGet,
CATEGORY(Particules generator) PARAM_STRING(GeneratorName),
"Set or Remove particle mass media",
{
u32 PGeneratorIndex;
if (GetPGeneratorFromString(GeneratorName, &PGeneratorIndex))
{
RETURN_STRING(ID_PGENERATOR[PGeneratorIndex]->MassTextureName);
}
})
DEFINE_SCRIPT(PGEN_MassTextureSet,
CATEGORY(Particules generator) PARAM_STRING(GeneratorName) PARAM_STRING(media),
"Set or Remove particle mass media",
{
u32 PGeneratorIndex;
u32 PMediaIndex;
if (GetPGeneratorFromString(GeneratorName, &PGeneratorIndex))
{
if (*ID_PGENERATOR[PGeneratorIndex]->MassTextureName &&
GetMediaFromString(ID_PGENERATOR[PGeneratorIndex]->MassTextureName, &PMediaIndex))
DestroyMedia(PMediaIndex);
if (*media)
CreateMedia(media, 0);
strcpy(ID_PGENERATOR[PGeneratorIndex]->MassTextureName, media);
}
})
DEFINE_SCRIPT(PGEN_SceneGet,
CATEGORY(Particules generator) PARAM_STRING(GeneratorName),
"Get particle scene",
{
u32 PGeneratorIndex;
if (GetPGeneratorFromString(GeneratorName, &PGeneratorIndex))
{
RETURN_STRING(ID_PGENERATOR[PGeneratorIndex]->SceneName);
}
})
DEFINE_SCRIPT(PGEN_SceneSet,
CATEGORY(Particules generator) PARAM_STRING(GeneratorName) PARAM_STRING(scene),
"Set particle scene",
{
u32 PGeneratorIndex;
if (GetPGeneratorFromString(GeneratorName, &PGeneratorIndex))
{
strcpy(ID_PGENERATOR[PGeneratorIndex]->SceneName, scene);
}
})
DEFINE_SCRIPT(PGEN_SceneObjectGet,
CATEGORY(Particules generator) PARAM_STRING(GeneratorName),
"Get particle scene object",
{
u32 PGeneratorIndex;
if (GetPGeneratorFromString(GeneratorName, &PGeneratorIndex))
{
RETURN_STRING(ID_PGENERATOR[PGeneratorIndex]->ObjectName);
}
})
DEFINE_SCRIPT(PGEN_SceneObjectSet,
CATEGORY(Particules generator) PARAM_STRING(GeneratorName) PARAM_STRING(object),
"Set particle scene object",
{
u32 PGeneratorIndex;
if (GetPGeneratorFromString(GeneratorName, &PGeneratorIndex))
{
strcpy(ID_PGENERATOR[PGeneratorIndex]->ObjectName, object);
}
})
DEFINE_SCRIPT(PGEN_PGRExplore,
CATEGORY(Small Scene) PARAM_STRING(PGRFile),
"Open PGR file",
{
char PGR[2048];
char TEXT[2048];
char TEXT2[2048];
FILE *F;
strcpy(PGR, PGRFile);
if (GetFileNameExtend(PGR) != '.PGR')
strcat(PGR, ".PGR");
sprintf(TEXT,".\\Particles\\%s", PGR);
F = fopen(TEXT,"rb");
if (F)
{
fclose(F);
sprintf(TEXT2,"CMD /C START %s", TEXT);
WinExec(TEXT2,SW_HIDE);
}
})
DEFINE_SCRIPT(FUR_Load,
CATEGORY(Fur generator) PARAM_STRING(Name) PARAM_STRING(GeneratorFileName) PARAM_STRING(SmallSceneName) PARAM_STRING_OPT(SceneObject,""),
"Load fur generator",
{
if (LoadFur(Name, GeneratorFileName, SmallSceneName, SceneObject) < 0)
sprintf(LuaErrors, "Error Creating Particule Generator");
})
DEFINE_SCRIPT(FUR_Delete,
CATEGORY(Fur generator) PARAM_STRING(Name),
"Delete fur generator",
{
DeleteFur(Name);
})
DEFINE_SCRIPT(FUR_Save,
CATEGORY(Fur generator) PARAM_STRING(Name) PARAM_STRING_OPT(newFilename, "") PARAM_INT_OPT(fullPath, 0),
"save particule generator file",
{
SaveFur(Name, newFilename, fullPath);
})
DEFINE_SCRIPT(FUR_Render,
CATEGORY(Fur generator) PARAM_STRING(GeneratorName) PARAM_STRING_OPT(SmallSceneName,""),
"if [Generator Name] = 'All', process all furs",
{
u32 FurIndex;
char GeneratorNameIn[2048];
strcpy(GeneratorNameIn, GeneratorName);
strlwr(GeneratorNameIn);
//if (!(SkipFunctions & SKIP_PARTICLES))
{
if (strcmp(GeneratorNameIn, "all"))
{
if (GetFurFromString(GeneratorNameIn, &FurIndex))
RenderFur(ID_FUR[FurIndex], SmallSceneName);
} else
{
for (int furIdx=0; furIdx<MAX_FUR; furIdx++)
{
if (!ID_FUR[furIdx]) continue;
RenderFur(ID_FUR[furIdx], SmallSceneName);
}
}
}
})
DEFINE_SCRIPT(FUR_Restart,
CATEGORY(Fur generator) PARAM_STRING(GeneratorName),
"if [Generator Name] = 'All', process all furs",
{
u32 FurIndex;
char GeneratorNameIn[2048];
strcpy(GeneratorNameIn, GeneratorName);
strlwr(GeneratorNameIn);
//if (!(SkipFunctions & SKIP_PARTICLES))
{
if (strcmp(GeneratorNameIn, "all"))
{
if (GetFurFromString(GeneratorNameIn, &FurIndex))
{
ID_FUR[FurIndex]->Init();
RETURN_BOOL(1);
} else
{
RETURN_BOOL(0);
}
} else
{
for (int furIdx=0; furIdx<MAX_PGENERATOR; furIdx++)
{
if (!ID_FUR[furIdx]) continue;
ID_FUR[furIdx]->Init();
}
}
}
})
DEFINE_SCRIPT(FUR_Debug,
CATEGORY(Fur generator) PARAM_INT_OPT(debug,1),
"Draw debug info",
{
FurDebug = debug;
})
DEFINE_SCRIPT(FUR_GeneratorSet,
CATEGORY(Fur generator config) PARAM_FUR(Fur) PARAM_STRING(GeneratorName),
"Set Fur generator Generator",
{
strcpy(Fur->GeneratorName, GeneratorName);
ComputeFurOptions(Fur);
})
DEFINE_SCRIPT(FUR_GeneratorGet,
CATEGORY(Fur generator config) PARAM_FUR(Fur),
"Get Fur generator Generator",
{
RETURN_STRING(Fur->GeneratorName);
})
DEFINE_SCRIPT(FUR_SceneSet,
CATEGORY(Fur generator config) PARAM_FUR(Fur) PARAM_STRING(SceneName),
"Set Fur generator Scene",
{
strcpy(Fur->SceneName, SceneName);
ComputeFurOptions(Fur);
})
DEFINE_SCRIPT(FUR_SceneGet,
CATEGORY(Fur generator config) PARAM_FUR(Fur),
"Get Fur generator Scene",
{
RETURN_STRING(Fur->SceneName);
})
DEFINE_SCRIPT(FUR_ObjectSet,
CATEGORY(Fur generator config) PARAM_FUR(Fur) PARAM_STRING(ObjectName),
"Set Fur generator Object",
{
strcpy(Fur->ObjectName, ObjectName);
ComputeFurOptions(Fur);
})
DEFINE_SCRIPT(FUR_ObjectGet,
CATEGORY(Fur generator config) PARAM_FUR(Fur),
"Get Fur generator Object",
{
RETURN_STRING(Fur->ObjectName);
})
DEFINE_SCRIPT(FUR_CONF_ModeSet,
CATEGORY(Fur generator config) PARAM_FUR(Fur) PARAM_INT(Value),
"Set Fur generator config Mode",
{
Fur->Mode = Value;
})
DEFINE_SCRIPT(FUR_CONF_ModeGet,
CATEGORY(Fur generator config) PARAM_FUR(Fur),
"Get Fur generator config Mode",
{
RETURN_INT(Fur->Mode);
})
DEFINE_SCRIPT(FUR_CONF_NbElmtSet,
CATEGORY(Fur generator config) PARAM_FUR(Fur) PARAM_INT(Value),
"Set Fur generator config nbFurElmt",
{
Fur->nbFurElmt = Value;
})
DEFINE_SCRIPT(FUR_CONF_NbElmtGet,
CATEGORY(Fur generator config) PARAM_FUR(Fur),
"Get Fur generator config nbFurElmt",
{
RETURN_INT(Fur->nbFurElmt);
})
DEFINE_SCRIPT(FUR_CONF_SpriteTextureMatNameSet,
CATEGORY(Fur generator config) PARAM_FUR(Fur) PARAM_STRING(Value),
"Set Fur generator config SpriteTextureMatName",
{
SetFurMaterial(Fur, Value);
})
DEFINE_SCRIPT(FUR_CONF_SpriteTextureMatNameGet,
CATEGORY(Fur generator config) PARAM_FUR(Fur),
"Get Fur generator config SpriteTextureMatName",
{
RETURN_STRING(Fur->SpriteTextureMatName);
})
DEFINE_SCRIPT(FUR_CONF_MassTextureNameSet,
CATEGORY(Fur generator config) PARAM_FUR(Fur) PARAM_STRING(Value),
"Set Fur generator config MassTextureName",
{
strcpy(Fur->MassTextureName, Value);
})
DEFINE_SCRIPT(FUR_CONF_MassTextureNameGet,
CATEGORY(Fur generator config) PARAM_FUR(Fur),
"Get Fur generator config MassTextureName",
{
RETURN_STRING(Fur->MassTextureName);
})
DEFINE_SCRIPT(FUR_CONF_SpriteWidthSet,
CATEGORY(Fur generator config) PARAM_FUR(Fur) PARAM_FLOAT(Value),
"Set Fur generator config SpriteWidth",
{
Fur->SpriteWidth = Value;
})
DEFINE_SCRIPT(FUR_CONF_SpriteWidthGet,
CATEGORY(Fur generator config) PARAM_FUR(Fur),
"Get Fur generator config SpriteWidth",
{
RETURN_FLOAT(Fur->SpriteWidth);
})
DEFINE_SCRIPT(FUR_CONF_SpriteWidthRandSet,
CATEGORY(Fur generator config) PARAM_FUR(Fur) PARAM_FLOAT(Value),
"Set Fur generator config SpriteWidthRand",
{
Fur->SpriteWidthRand = Value;
})
DEFINE_SCRIPT(FUR_CONF_SpriteWidthRandGet,
CATEGORY(Fur generator config) PARAM_FUR(Fur),
"Get Fur generator config SpriteWidthRand",
{
RETURN_FLOAT(Fur->SpriteWidthRand);
})
DEFINE_SCRIPT(FUR_CONF_SpriteHeightSet,
CATEGORY(Fur generator config) PARAM_FUR(Fur) PARAM_FLOAT(Value),
"Set Fur generator config SpriteHeight",
{
Fur->SpriteHeight = Value;
})
DEFINE_SCRIPT(FUR_CONF_SpriteHeightGet,
CATEGORY(Fur generator config) PARAM_FUR(Fur),
"Get Fur generator config SpriteHeight",
{
RETURN_FLOAT(Fur->SpriteHeight);
})
DEFINE_SCRIPT(FUR_CONF_SpriteHeightRandSet,
CATEGORY(Fur generator config) PARAM_FUR(Fur) PARAM_FLOAT(Value),
"Set Fur generator config SpriteHeightRand",
{
Fur->SpriteHeightRand = Value;
})
DEFINE_SCRIPT(FUR_CONF_SpriteHeightRandGet,
CATEGORY(Fur generator config) PARAM_FUR(Fur),
"Get Fur generator config SpriteHeightRand",
{
RETURN_FLOAT(Fur->SpriteHeightRand);
})
DEFINE_SCRIPT(FUR_CONF_SpritePositionSet,
CATEGORY(Fur generator config) PARAM_FUR(Fur) PARAM_FLOAT(Value),
"Set Fur generator config SpritePosition",
{
Fur->SpritePosition = Value;
})
DEFINE_SCRIPT(FUR_CONF_SpritePositionGet,
CATEGORY(Fur generator config) PARAM_FUR(Fur),
"Get Fur generator config SpritePosition",
{
RETURN_FLOAT(Fur->SpritePosition);
})
DEFINE_SCRIPT(FUR_CONF_SpriteLevelsSet,
CATEGORY(Fur generator config) PARAM_FUR(Fur) PARAM_INT(Value),
"Set Fur generator config SpriteLevels",
{
Fur->SpriteLevels = Value;
})
DEFINE_SCRIPT(FUR_CONF_SpriteLevelsGet,
CATEGORY(Fur generator config) PARAM_FUR(Fur),
"Get Fur generator config SpriteLevels",
{
RETURN_INT(Fur->SpriteLevels);
})
DEFINE_SCRIPT(FUR_CONF_OrientationStrenghSet,
CATEGORY(Fur generator config) PARAM_FUR(Fur) PARAM_FLOAT(Value),
"Set Fur generator config OrientationStrengh",
{
Fur->OrientationStrengh = Value;
})
DEFINE_SCRIPT(FUR_CONF_OrientationStrenghGet,
CATEGORY(Fur generator config) PARAM_FUR(Fur),
"Get Fur generator config OrientationStrengh",
{
RETURN_FLOAT(Fur->OrientationStrengh);
})
DEFINE_SCRIPT(FUR_CONF_ElasticitySet,
CATEGORY(Fur generator config) PARAM_FUR(Fur) PARAM_FLOAT(Value),
"Set Fur generator config Elasticity",
{
Fur->OrientationMeca.elasticity = Value;
})
DEFINE_SCRIPT(FUR_CONF_ElasticityGet,
CATEGORY(Fur generator config) PARAM_FUR(Fur),
"Get Fur generator config Elasticity",
{
RETURN_FLOAT(Fur->OrientationMeca.elasticity);
})
DEFINE_SCRIPT(FUR_CONF_FrictionSet,
CATEGORY(Fur generator config) PARAM_FUR(Fur) PARAM_FLOAT(Value),
"Set Fur generator config Friction",
{
Fur->OrientationMeca.friction = Value;
})
DEFINE_SCRIPT(FUR_CONF_FrictionGet,
CATEGORY(Fur generator config) PARAM_FUR(Fur),
"Get Fur generator config Friction",
{
RETURN_FLOAT(Fur->OrientationMeca.friction);
})
DEFINE_SCRIPT(FUR_CONF_NbOrientationSet,
CATEGORY(Fur generator config) PARAM_FUR(Fur) PARAM_INT(Value),
"Set Fur generator config nbOrientation",
{
if (Value > 0)
{
if (Fur->OrientationList)
Fur->OrientationList = (Vector *)CC_realloc(Fur->OrientationList, Value*sizeof(Vector));
else
Fur->OrientationList = (Vector *)CC_malloc(Value*sizeof(Vector));
} else
if (Fur->OrientationList)
{
CC_free(Fur->OrientationList);
Fur->OrientationList = NULL;
}
if (Fur->nbOrientation < Value)
memset(Fur->OrientationList + Fur->nbOrientation, 0, (Value-Fur->nbOrientation)*sizeof(Vector));
Fur->nbOrientation = Value;
})
DEFINE_SCRIPT(FUR_CONF_NbOrientationGet,
CATEGORY(Fur generator config) PARAM_FUR(Fur),
"Get Fur generator config nbOrientation",
{
RETURN_FLOAT(Fur->nbOrientation);
})
DEFINE_SCRIPT(FUR_CONF_OrientationSet,
CATEGORY(Fur generator config) PARAM_FUR(Fur) PARAM_INT(index) PARAM_VECTOR(Value),
"Set Fur generator config Orientation",
{
if (index < Fur->nbOrientation)
Fur->OrientationList[index] = Value;
})
DEFINE_SCRIPT(FUR_CONF_OrientationGet,
CATEGORY(Fur generator config) PARAM_FUR(Fur) PARAM_INT(index),
"Get Fur generator config Orientation",
{
if (index < Fur->nbOrientation)
{ RETURN_VECTOR(&Fur->OrientationList[index]);}
})
DEFINE_SCRIPT(PICK_EpsilonSet,
CATEGORY(Picking) PARAM_FLOAT(Epsilon),
"Change picking Z tolerance",
{
extern float PIKING_EPSILLON;
PIKING_EPSILLON = Epsilon;
})
DEFINE_SCRIPT(PICK_EpsilonGet,
CATEGORY(Picking),
"Get current picking Z tolerance",
{
extern float PIKING_EPSILLON;
RETURN_FLOAT(PIKING_EPSILLON);
})
DEFINE_SCRIPT_REN(PICK_FlagSet, PICK_SetFlag,CATEGORY(Picking) PARAM_STRING(FlagName),"If the name is not empty and different than '0', enable picking (!! Time consuming !! )<br/>This Flag allow you to know when picking happen",
{
if (*FlagName == 0 || !strcmp(FlagName, "0") || (SkipFunctions & SKIP_PICKING))
{
*PickReportCurrent.PickingClass = 0;
DI->PickingEnable = 0;
} else
{
strcpy(PickReportCurrent.PickingClass, FlagName);
DI->PickingEnable = hasFocus;
}
})
DEFINE_SCRIPT_REN(PICK_FlagGet, PICK_GetFlag,CATEGORY(Picking),"Return the pick flag active when picking occurs",
{
RETURN_STRING(PickReportToWatch.PickingClass);
})
DEFINE_SCRIPT(PICK_FlagCurrentGet,CATEGORY(Picking),"Return the pick flag active when picking occurs",
{
RETURN_STRING(PickReportResult.PickingClass);
})
DEFINE_SCRIPT(PICK_CaptureSet,CATEGORY(Picking) PARAM_INT(OnOff),"Force to keep focus if 1, even if mouse is outside the main window. 0 will release this option",
{
extern void WINMAIN_SETCAPTURE(u32 OnOff);
CaptureMode = OnOff && *PickReportFinal.PickingClass;
WINMAIN_SETCAPTURE(CaptureMode);
})
DEFINE_SCRIPT(PICK_CoordLocalGet,CATEGORY(Picking),"If a small scene has been picked, return LOCAL XYZ else '0'",
{
if (*PickReportToWatch.PickingClass && PickReportToWatch.CollidedSmallSceneGameObjectName[0])
{ RETURN_VECTOR(&PickReportToWatch.PickingCoordXYZ_Local); }
})
DEFINE_SCRIPT(PICK_CoordGlobalGet,CATEGORY(Picking),"If a small scene has been picked, return GLOBAL XYZ else '0'",
{
if (*PickReportToWatch.PickingClass && PickReportToWatch.CollidedSmallSceneGameObjectName[0])
{ RETURN_VECTOR(&PickReportToWatch.PickingCoordXYZ_Global); }
})
DEFINE_SCRIPT_REN(PICK_SmallSceneNameGet, PICK_GetSmallSceneName,CATEGORY(Picking),"If a small scene has been picked, return SmallScene Name, else '0'",
{
if (*PickReportToWatch.PickingClass && PickReportToWatch.CollidedSmallSceneName[0])
{ RETURN_STRING(PickReportToWatch.CollidedSmallSceneName); }
})
DEFINE_SCRIPT_REN(PICK_SmallSceneObjectNameGet, PICK_GetSmallSceneObjectName,CATEGORY(Picking),"If a small scene has been picked, return SmallScene Object Name, else '0'",
{
if (*PickReportToWatch.PickingClass && PickReportToWatch.CollidedSmallSceneGameObjectName[0])
{ RETURN_STRING(PickReportToWatch.CollidedSmallSceneGameObjectName); }
})
DEFINE_SCRIPT(PICK_SmallMaterialNameGet,CATEGORY(Picking),"If a small scene has been picked, return SmallScene Material Name, else '0'",
{
if (*PickReportToWatch.PickingClass && PickReportToWatch.CollidedSmallMaterialName[0])
{ RETURN_STRING(PickReportToWatch.CollidedSmallMaterialName); }
})
DEFINE_SCRIPT(SCN_PointScreenToScene,
CATEGORY(Small Scene) PARAM_SCENE(Smsc) PARAM_VECTOR(ScreenPoint) ,
"Transform screen point into the smallescene coordinate",
{
ScreenPoint = ScreenPointToScene(Smsc, ScreenPoint);
RETURN_VECTOR(&ScreenPoint);
})
DEFINE_SCRIPT(SCN_PointSceneToScreen,
CATEGORY(Small Scene) PARAM_SCENE(Smsc) PARAM_VECTOR(ScenePoint) ,
"Transform screen point into the smallescene coordinate",
{
ScenePoint = ScenePointToScreen(Smsc, ScenePoint);
RETURN_VECTOR(&ScenePoint);
})
DEFINE_SCRIPT_REN(PICK_MediaNameGet, PICK_GetPickedMediaName,CATEGORY(Picking),"If a media was associated to the picking return his name, else '0'",
{
if (*PickReportToWatch.PickingClass && PickReportToWatch.CollidedMap)
{
if (PickReportToWatch.CollidedMediaName[0] == 0)
{
for (u32 Counter = 0 ; Counter < MAX_INPMED ; Counter++)
{
if (ID_MEDIA[Counter] && (&ID_MEDIA[Counter]->Image == PickReportToWatch.CollidedMap))
{
strcpy((char*)PickReportToWatch.CollidedMediaName,(char*)ID_MEDIA[Counter]->MediaName);
Counter = MAX_INPMED;
}
}
}
if (PickReportToWatch.CollidedMediaName[0] == 0)
PickReportToWatch.CollidedMap = NULL;
else
{ RETURN_STRING(PickReportToWatch.CollidedMediaName); }
}
})
DEFINE_SCRIPT(PICK_MediaNicknameGet,CATEGORY(Picking),"If a media was associated to the picking return his nickname, else '0'",
{
if (*PickReportToWatch.PickingClass && PickReportToWatch.CollidedMap)
{
if (PickReportToWatch.CollidedMediaNickname[0] == 0)
{
for (u32 Counter = 0 ; Counter < MAX_INPMED ; Counter++)
{
if (ID_MEDIA[Counter] && (&ID_MEDIA[Counter]->Image == PickReportToWatch.CollidedMap))
{
strcpy((char*)PickReportToWatch.CollidedMediaNickname,(char*)ID_MEDIA[Counter]->Nickname);
Counter = MAX_INPMED;
}
}
}
if (PickReportToWatch.CollidedMediaNickname[0] != 0)
{ RETURN_STRING(PickReportToWatch.CollidedMediaNickname); }
}
})
DEFINE_SCRIPT_REN(PICK_ColorGet, PICK_GetColor,CATEGORY(Picking),"If a media was associated to the picking, return the color of the pick, else '0'",
{
if (*PickReportToWatch.PickingClass && PickReportToWatch.CollidedMap)
{
if (PickReportToWatch.CollidedMediaName[0] == 0)
{
for (u32 Counter = 0 ; Counter < MAX_INPMED ; Counter++)
{
if (ID_MEDIA[Counter] && (&ID_MEDIA[Counter]->Image == PickReportToWatch.CollidedMap))
{
strcpy((char*)PickReportToWatch.CollidedMediaName,(char*)ID_MEDIA[Counter]->MediaName);
Counter = MAX_INPMED;
}
}
}
if (PickReportToWatch.CollidedMediaName[0] == 0)
PickReportToWatch.CollidedMap = NULL;
else
{ RETURN_COLOR(0xFFFFFF & PickReportToWatch.CollidedMap->GetValue((int)PickReportToWatch.PickingCoordUV.x + (int)PickReportToWatch.PickingCoordUV.y*PickReportToWatch.CollidedMap->PITCH)); }
}
})
DEFINE_SCRIPT_REN(PICK_MediaXYGet, PICK_GetMediaXY, CATEGORY(Picking),"If a media was associated to the picking return the texture coords of the picking point, else '0'",
{
if (*PickReportToWatch.PickingClass && PickReportToWatch.CollidedMap)
{
if (PickReportToWatch.CollidedMediaName[0] == 0)
{
for (u32 Counter = 0 ; Counter < MAX_INPMED ; Counter++)
{
if (ID_MEDIA[Counter] && (&ID_MEDIA[Counter]->Image == PickReportToWatch.CollidedMap))
{
strcpy((char*)PickReportToWatch.CollidedMediaName,(char*)ID_MEDIA[Counter]->MediaName);
Counter = MAX_INPMED;
}
}
}
if (PickReportToWatch.CollidedMediaName[0] == 0)
PickReportToWatch.CollidedMap = NULL;
else
{ RETURN_POINTF(PickReportToWatch.PickingCoordUV.x, PickReportToWatch.CollidedMap->SY - PickReportToWatch.PickingCoordUV.y); }
}
})
DEFINE_SCRIPT(PICK_CaptureGrowSet,
CATEGORY(Picking) PARAM_INT(Size),
"Make grow tolerancy of picking by [SIZE] pixels",
{
PickReportCurrent.GrowCaptureSize = Size;
})
DEFINE_SCRIPT(PICK_AlphaThresholdSet,
CATEGORY(Picking) PARAM_INT(ALPHA),
"Set the alpha picking sensitivity.0 mean pick everything.Range is 0-256",
{
PickReportCurrent.AlphaThreshold = ALPHA;
})
DEFINE_SCRIPT_REN(SCN_FocaleSet, SetSmScFocale,
CATEGORY(Small Scene) PARAM_SCENE(Smsc) PARAM_FLOAT(NewFocale),
"Negative numbers mean ORTHO (ISOMETRIC) Focale",
{
if(Smsc) Smsc->fFocalToUseForNextRender = NewFocale;
})
DEFINE_SCRIPT(SCN_FocaleGet,
CATEGORY(Small Scene) PARAM_SCENE(Smsc),
"Get the focal of a small scene. Negative numbers mean ORTHO (ISOMETRIC) Focale.",
{
float focale = Smsc->fFocalToUseForNextRender;
if (focale ==0) focale = 2.5;
if(Smsc) RETURN_FLOAT(focale);
})
DEFINE_SCRIPT(VECTOR_New, CATEGORY(VECTOR) PARAM_FLOAT_OPT(x,0) PARAM_FLOAT_OPT(y,0) PARAM_FLOAT_OPT(z,0) , "Create Null Vector",
{
Vector newVector(x,y,z);
RETURN_VECTOR(&newVector);
})
DEFINE_SCRIPT(QUAT_New, CATEGORY(QUAT) PARAM_FLOAT_OPT(x,0) PARAM_FLOAT_OPT(y,0) PARAM_FLOAT_OPT(z,0) PARAM_FLOAT_OPT(w,0) , "Create Indetity quaternion",
{
Quat newQuat(x,y,z,w);
RETURN_QUAT(&newQuat);
})
DEFINE_SCRIPT(MATRIX_New, CATEGORY(MATRIX), "Create Indetity matrix",
{
MATRIX Identity;
RETURN_MATRIX(&Identity);
})
DEFINE_SCRIPT(MATRIX_RotateI,CATEGORY(MATRIX) PARAM_MATRIX(Pos) PARAM_FLOAT(Angle),"Angle is in degree",
{
Pos.RotateAround_I(Angle * 3.1415927f / 180.0f);
RETURN_MATRIX(&Pos);
})
DEFINE_SCRIPT(MATRIX_RotateJ,CATEGORY(MATRIX) PARAM_MATRIX(Pos) PARAM_FLOAT(Angle),"Angle is in degree",
{
Pos.RotateAround_J(Angle * 3.1415927f / 180.0f);
RETURN_MATRIX(&Pos);
})
DEFINE_SCRIPT(MATRIX_RotateK,CATEGORY(MATRIX) PARAM_MATRIX(Pos) PARAM_FLOAT(Angle),"Angle is in degree",
{
Pos.RotateAround_K(Angle * 3.1415927f / 180.0f);
RETURN_MATRIX(&Pos);
})
DEFINE_SCRIPT(MATRIX_RotateX,CATEGORY(MATRIX) PARAM_MATRIX(Pos) PARAM_FLOAT(Angle),"Angle is in degree",
{
Pos.RotateAround_X(Angle * 3.1415927f / 180.0f);
RETURN_MATRIX(&Pos);
})
DEFINE_SCRIPT(MATRIX_RotateY,CATEGORY(MATRIX) PARAM_MATRIX(Pos) PARAM_FLOAT(Angle),"Angle is in degree",
{
Pos.RotateAround_Y(Angle * 3.1415927f / 180.0f);
RETURN_MATRIX(&Pos);
})
DEFINE_SCRIPT(MATRIX_RotateZ,CATEGORY(MATRIX) PARAM_MATRIX(Pos) PARAM_FLOAT(Angle),"Angle is in degree",
{
Pos.RotateAround_Z(Angle * 3.1415927f / 180.0f);
RETURN_MATRIX(&Pos);
})
DEFINE_SCRIPT(MATRIX_RotationAmplify,
CATEGORY(MATRIX) PARAM_MATRIX(RotationMatrix) PARAM_FLOAT(factor) PARAM_FLOAT_OPT(angleLimit, -1),
"Amplify or reduct a rotation matrix",
{
Vector Tranlation = RotationMatrix.T;
void MatrixStretchAngle(MATRIX *MatrixPtr, float factor, float limit);
MatrixStretchAngle(&RotationMatrix, factor, angleLimit);
RotationMatrix.T = Tranlation;
RETURN_MATRIX(&RotationMatrix);
})
DEFINE_SCRIPT(MATRIX_ToEuler,
CATEGORY(MATRIX) PARAM_MATRIX(matrix),
"Amplify or reduct a rotation matrix",
{
Vector EulerVect;
matrix.ToEuler(EulerVect);
EulerVect *= 45 / atan(1.0);
RETURN_VECTOR(&EulerVect);
})
DEFINE_SCRIPT(MATRIX_FromEuler,
CATEGORY(MATRIX) PARAM_VECTOR(EulerVect),
"Amplify or reduct a rotation matrix",
{
MATRIX matrix;
EulerVect *= atan(1.0) / 45;
matrix.FromEuler(EulerVect);
RETURN_MATRIX(&matrix);
})
DEFINE_SCRIPT(MATRIX_ToQuat,
CATEGORY(MATRIX) PARAM_MATRIX(matrix),
"Amplify or reduct a rotation matrix",
{
Quat quat;
quat.ComputeFromMatrix(&matrix);
RETURN_QUAT(&quat);
})
DEFINE_SCRIPT(MATRIX_FromQuat,
CATEGORY(MATRIX) PARAM_QUAT(quat),
"Amplify or reduct a rotation matrix",
{
MATRIX matrix;
quat.TransforToMatrix(&matrix);
RETURN_MATRIX(&matrix);
})
DEFINE_SCRIPT(MATRIX_Inverse,
CATEGORY(MATRIX) PARAM_MATRIX(matrix),
"Inverse the matrix",
{
MATRIX matrixDst;
matrix.Inverse(matrixDst);
RETURN_MATRIX(&matrixDst);
})
DEFINE_SCRIPT(MATRIX_ZoomSet,CATEGORY(MATRIX) PARAM_MATRIX(Pos) PARAM_VECTOR(Zoom),"Zoom is a Factor",
{
Pos.I.Normalize();
Pos.J.Normalize();
Pos.K.Normalize();
Pos.I *= Zoom.x;
Pos.J *= Zoom.y;
Pos.K *= Zoom.z;
RETURN_MATRIX(&Pos);
})
DEFINE_SCRIPT(MATRIX_ZoomGet,CATEGORY(MATRIX) PARAM_MATRIX(Pos),"",
{
Vector Zoom;
Zoom.x = Pos.I.Norm();
Zoom.y = Pos.J.Norm();
Zoom.z = Pos.K.Norm();
RETURN_VECTOR(&Zoom);
})
DEFINE_SCRIPT(MATRIX_Blend,CATEGORY(MATRIX) PARAM_MATRIX(Pos1) PARAM_MATRIX(Pos2) PARAM_FLOAT(Factor),"",
{
Pos1.Blend(Pos2,Factor);
RETURN_MATRIX(&Pos1);
})
DEFINE_SCRIPT(TRK_ComputeBackground,
CATEGORY(Tracking) PARAM_INT(Activate) PARAM_INT(Relearn),
"Compute back. Store result in alpha channel",
{
u32 TRK_AE_ComputeBackground(u32 Activate, u32 Relearn);
RETURN_INT(TRK_AE_ComputeBackground(Activate,Relearn));
})
DEFINE_SCRIPT(TRK_ComputeBackgroundParrams,
CATEGORY(Tracking) PARAM_INT(Blur) PARAM_INT(Blur_Summ),
"Compute back denoise parrams. ",
{
void TRK_AE_ComputeBackgroundParrams(s32 FactorBlur, s32 FactorBlurSumm);
TRK_AE_ComputeBackgroundParrams(Blur, Blur_Summ);
})
DEFINE_SCRIPT(TRK_FrameHasBeenSkipped,
CATEGORY(Tracking),
"Return 0 if tracker has been called",
{
RETURN_INT(ulSkippedFrameCounter);
})
DEFINE_SCRIPT(MAT_SaveIn,
CATEGORY(Material) PARAM_SCENE_MATERIAL(Smsc, Material) PARAM_STRING(SmscToAdd) PARAM_STRING(MaterialToAdd),
"save material",
{
SaveMaterial(Material, SmscToAdd, MaterialToAdd);
})
DEFINE_SCRIPT(IK_Check,
CATEGORY(IK) PARAM_SCENE(SmSc),
"Check IK",
{
if (!SmSc->IK)
{
SmSc->IK = (SmallScene_IK *)CC_malloc(sizeof(SmallScene_IK));
memset(SmSc->IK, 0, sizeof(SmallScene_IK));
SmSc->IODico.Init();
}
})
DEFINE_SCRIPT(IK_Reset,
CATEGORY(IK) PARAM_STRING(SceneName),
"Set an empty IK (reset existing or create)",
{
SmallSceneIKReset(SceneName);
})
DEFINE_SCRIPT(IK_Save,
CATEGORY(IK) PARAM_STRING(SceneName),
"Save IK File",
{
char NameIK[2048];
u32 res;
SmallScene *Smsc = SmallNameToScene(SceneName);
sprintf(NameIK,".\\media\\%s\\Modified\\SmSc.IKM",SceneName);
IKPatchInitToObj(Smsc);
res = SaveSmallScene_IK(Smsc->IK,NameIK, &Smsc->IODico);
IKPatchProcess(Smsc);
RETURN_BOOL(res == NULL);
})
DEFINE_SCRIPT(IK_PatchNumberSet,
CATEGORY(IK) PARAM_SCENE_IK(SceneName) PARAM_INT(Number),
"Set Patch number",
{
if (IKPtr->ulInitNumberOfPatchs < Number)
{
if (!IKPtr->pInitObjPatchs)
IKPtr->pInitObjPatchs = (IK_ObjectPatch *)CC_malloc(SceneName->ulNumberOfObjects*sizeof(IK_ObjectPatch));
memset(IKPtr->pInitObjPatchs + IKPtr->ulInitNumberOfPatchs, 0, (Number - IKPtr->ulInitNumberOfPatchs)*sizeof(IK_ObjectPatch));
}
IKPtr->ulInitNumberOfPatchs = Number;
IKPatchProcess(SceneName);
SmallSceneIKInstancesReset(SceneName);
})
DEFINE_SCRIPT(IK_PatchNumberGet,
CATEGORY(IK) PARAM_SCENE_IK(SceneName),
"Get Patch number",
{
RETURN_INT(IKPtr->ulInitNumberOfPatchs);
})
DEFINE_SCRIPT(IK_PatchObjectSet,
CATEGORY(IK) PARAM_SCENE_IK_PATCH(Smsc, patch) PARAM_STRING(ObjectName),
"Set patch Object",
{
UnicID ObjectID = -1;
UnicID ObjectREF= -1;
char *lastSlash = ObjectName;
while (strchr(lastSlash, '\\'))
lastSlash = strchr(lastSlash, '\\') + 1;
while (strchr(lastSlash, '/'))
lastSlash = strchr(lastSlash, '/') + 1;
ObjectREF = Smsc->ObjectNameDico.IsExist(lastSlash);
if (ObjectREF != -1)
ObjectREF = Smsc->ObjectNameDico.mpst_Dico[ObjectREF].AssociatedValue;
//ObjectID = Smsc->IODico.IsExist(Object);
if (ObjectREF != -1)
{
Smsc->IODico.GetUnic(&ObjectID, ObjectName);
Smsc->IODico.mpst_Dico[ObjectID].AssociatedValue = ObjectREF;
patch->ObjectID = ObjectID;
patch->ObjectRefIndex = ObjectREF;
IKPatchProcess(Smsc);
SmallSceneIKInstancesReset(Smsc);
}
RETURN_BOOL(patch->ObjectID != -1);
})
DEFINE_SCRIPT(IK_PatchObjectGet,
CATEGORY(IK) PARAM_SCENE_IK_PATCH(SceneName, patch),
"Get patch Object Name",
{
char ObjectName[2048];
SceneName->IODico.GetName(&patch->ObjectID, ObjectName);
RETURN_STRING(ObjectName);
})
DEFINE_SCRIPT(IK_PatchFlagSet,
CATEGORY(IK) PARAM_SCENE_IK_PATCH(SceneName, patch) PARAM_INT(Flag),
"Set Patch Flag",
{
patch->ulFlags = Flag;
IKPatchProcess(SceneName);
SmallSceneIKInstancesReset(SceneName);
})
DEFINE_SCRIPT(IK_PatchFlagGet,
CATEGORY(IK) PARAM_SCENE_IK_PATCH(SceneName, patch),
"Get Patch Flag",
{
RETURN_INT(patch->ulFlags);
})
DEFINE_SCRIPT(IK_PatchHeritageStartSet,
CATEGORY(IK) PARAM_SCENE_IK_PATCH(SceneName, patch) PARAM_INT(HeritageStart),
"Set Patch HeritageStart",
{
patch->HeritageStart = HeritageStart;
IKPatchProcess(SceneName);
SmallSceneIKInstancesReset(SceneName);
})
DEFINE_SCRIPT(IK_PatchHeritageStartGet,
CATEGORY(IK) PARAM_SCENE_IK_PATCH(SceneName, patch),
"Get Patch HeritageStart",
{
RETURN_INT(patch->HeritageStart);
})
DEFINE_SCRIPT(IK_PatchSpringStrengthSet,
CATEGORY(IK) PARAM_SCENE_IK_PATCH(SceneName, patch) PARAM_FLOAT(SpringStrength),
"Set Patch SpringStrength",
{
patch->fSpringStrength = SpringStrength;
IKPatchProcess(SceneName);
SmallSceneIKInstancesReset(SceneName);
})
DEFINE_SCRIPT(IK_PatchSpringStrengthGet,
CATEGORY(IK) PARAM_SCENE_IK_PATCH(SceneName, patch),
"Get Patch SpringStrength",
{
RETURN_FLOAT(patch->fSpringStrength);
})
DEFINE_SCRIPT(IK_PatchVelocityAbsorbtionSet,
CATEGORY(IK) PARAM_SCENE_IK_PATCH(SceneName, patch) PARAM_FLOAT(VelocityAbsorbtion),
"Set Patch VelocityAbsorbtion",
{
patch->VelocityAbsorbtion = VelocityAbsorbtion;
IKPatchProcess(SceneName);
SmallSceneIKInstancesReset(SceneName);
})
DEFINE_SCRIPT(IK_PatchVelocityAbsorbtionGet,
CATEGORY(IK) PARAM_SCENE_IK_PATCH(SceneName, patch),
"Get Patch VelocityAbsorbtion",
{
RETURN_FLOAT(patch->VelocityAbsorbtion);
})
DEFINE_SCRIPT(IK_PatchMaxAngleSet,
CATEGORY(IK) PARAM_SCENE_IK_PATCH(SceneName, patch) PARAM_FLOAT(MaxAngle),
"Set Patch MaxAngle in degrees",
{
patch->MaxAngle = MaxAngle/90.0f;
IKPatchProcess(SceneName);
SmallSceneIKInstancesReset(SceneName);
})
DEFINE_SCRIPT(IK_PatchMaxAngleGet,
CATEGORY(IK) PARAM_SCENE_IK_PATCH(SceneName, patch),
"Get Patch MaxAngle in degrees",
{
RETURN_FLOAT(patch->MaxAngle*90.0f);
})
DEFINE_SCRIPT(IK_PatchWeightSet,
CATEGORY(IK) PARAM_SCENE_IK_PATCH(SceneName, patch) PARAM_VECTOR(Weight),
"Set Patch Weight",
{
patch->vWeight = Weight;
IKPatchProcess(SceneName);
SmallSceneIKInstancesReset(SceneName);
})
DEFINE_SCRIPT(IK_PatchWeightGet,
CATEGORY(IK) PARAM_SCENE_IK_PATCH(SceneName, patch),
"Get Patch Weight",
{
RETURN_VECTOR(&patch->vWeight);
})
DEFINE_SCRIPT(IK_ColliderNumberSet,
CATEGORY(IK) PARAM_SCENE_IK(SceneName) PARAM_INT(Number),
"Set Collider number",
{
if (Number != IKPtr->ulNumberOfCollider)
{
if (Number == 0)
{
if (IKPtr->pColliders) CC_free(IKPtr->pColliders);
IKPtr->pColliders = NULL;
} else
{
if (!IKPtr->pColliders)
IKPtr->pColliders = (IK_Collider *)CC_malloc(Number*sizeof(IK_Collider));
else
IKPtr->pColliders = (IK_Collider *)CC_realloc(IKPtr->pColliders, Number*sizeof(IK_Collider));
}
if (IKPtr->ulNumberOfCollider < Number)
memset(IKPtr->pColliders + IKPtr->ulNumberOfCollider, 0, (Number - IKPtr->ulNumberOfCollider)*sizeof(IK_Collider));
IKPtr->ulNumberOfCollider = Number;
SmallSceneIKInstancesReset(SceneName);
}
})
DEFINE_SCRIPT(IK_ColliderNumberGet,
CATEGORY(IK) PARAM_SCENE_IK(SceneName),
"Get Collider number",
{
RETURN_INT(IKPtr->ulNumberOfCollider);
})
DEFINE_SCRIPT(IK_ColliderObjectSet,
CATEGORY(IK) PARAM_SCENE_IK_COLLIDER(Smsc, collider) PARAM_STRING(ObjectName),
"Set Collider Object",
{
UnicID ObjectID = -1;
UnicID ObjectREF= -1;
char *lastSlash = ObjectName;
while (strchr(lastSlash, '\\'))
lastSlash = strchr(lastSlash, '\\') + 1;
while (strchr(lastSlash, '/'))
lastSlash = strchr(lastSlash, '/') + 1;
ObjectREF = Smsc->ObjectNameDico.IsExist(lastSlash);
if (ObjectREF != -1)
ObjectREF = Smsc->ObjectNameDico.mpst_Dico[ObjectREF].AssociatedValue;
//ObjectID = Smsc->IODico.IsExist(Object);
if (ObjectREF != -1)
{
Smsc->IODico.GetUnic(&ObjectID, ObjectName);
Smsc->IODico.mpst_Dico[ObjectID].AssociatedValue = ObjectREF;
collider->ObjectID = ObjectID;
collider->ObjectRefIndex = Smsc->IODico.mpst_Dico[collider->ObjectID].AssociatedValue;
SmallSceneIKInstancesReset(Smsc);
}
RETURN_BOOL(collider->ObjectID != -1);
})
DEFINE_SCRIPT(IK_ColliderObjectGet,
CATEGORY(IK) PARAM_SCENE_IK_COLLIDER(SceneName, collider),
"Get Collider Object Name",
{
char ObjectName[2048];
SceneName->IODico.GetName(&collider->ObjectID, ObjectName);
RETURN_STRING(ObjectName);
})
DEFINE_SCRIPT(IK_ColliderRadiusSet,
CATEGORY(IK) PARAM_SCENE_IK_COLLIDER(SceneName, collider) PARAM_VECTOR(V),
"Set Collider Radius",
{
collider->Radius = V;
SmallSceneIKInstancesReset(SceneName);
})
DEFINE_SCRIPT(IK_ColliderRadiusGet,
CATEGORY(IK) PARAM_SCENE_IK_COLLIDER(SceneName, collider),
"Get Collider Radius",
{
RETURN_VECTOR(&collider->Radius);
})
DEFINE_SCRIPT(IK_ColliderCenterSet,
CATEGORY(IK) PARAM_SCENE_IK_COLLIDER(SceneName, collider) PARAM_VECTOR(V),
"Set Collider Center",
{
collider->Center = V;
SmallSceneIKInstancesReset(SceneName);
})
DEFINE_SCRIPT(IK_ColliderCenterGet,
CATEGORY(IK) PARAM_SCENE_IK_COLLIDER(SceneName, collider),
"Get Collider Center",
{
RETURN_VECTOR(&collider->Center);
})
Reference in a new issue View git blame Copy permalink