#ifndef _SCENE_H_
#define _SCENE_H_

#define LUA_DEBUG_MODE // May cause slower execution

#include "DEFINES.H"


#include "TRACK.H"
#include "Rrasters.h"
#include "MEDIA.H"
#include "NET.H"
#include "ID.H"
#include "DICO.H"
#include "3D.H"
#include "Particules.h"
#include "Fur.h"
#include "IO_STRUCTS.H"
#include "HeadDetector.h"
#include "ShotTracker.h"
#include "Fast2D.h"

#include "MicroIn.h"
#include "AVISave.h"

#include "TXT_Manager.h"
#include "INI_Manager.h"
#include "IniFileManager.h"
#include "CSV/CSV.H"

#include "Subtitles.h"

#include "lua.h"
#include "lualib.h"
#include "lauxlib.h"
#include "LuaEvents.h"
#include "FAST2Dtrack.h"
#include "wiimote.h"





typedef struct 
{
	s8 *String;
} CommandLine;

typedef struct 
{
	CommandLine BatchExec[2048];
	u32			ulNumberOfCommands;
} CommandBatch;

typedef struct MenuTextInfo_
{
	DWORD id;
	TCHAR text[128];
} MenuTextInfo;

/******** FUNCTION SKIP ********/
#define SKIP_TRACKER	(1<<0)
#define SKIP_RENDER		(1<<1)
#define SKIP_PICKING	(1<<2)
#define SKIP_DRAWING	(1<<3)
#define SKIP_MEDIA		(1<<4)
#define SKIP_AVI		(1<<5)
#define SKIP_REVERSE	(1<<6)
#define SKIP_EFFECTS	(1<<7)
#define SKIP_SOUND		(1<<8)
#define SKIP_PARTICLES	(1<<9)
#define SKIP_SKINNING	(1<<10)
#define SKIP_LIGHTING	(1<<11)
#define SKIP_SWITCH_NEW_INTEREST (1<<12)
#define SKIP_NODEBUG	(1<<13)
#define SKIP_NOMOSAIC	(1<<14)
#define SKIP_NOFPS		(1<<15)
#define SKIP_CAMERA		(1<<16)
#define SKIP_GLWRITE	(1<<17)
#define SKIP_GLREAD		(1<<18)
#define SKIP_NO_60hz_LIMIT (1<<19)
#define SKIP_MESHOPTIM	(1<<20)


/********* EVENT ************/
 /*1->End alone, 2->Prev alone, 16->compare prev and end apply end, 8-> compare prev and end apply prev, 16 compare click and end ARE same apply end, 32 compare click and end apply click*/
#define LUA_SRC_DEC				(8)
#define LUA_MODE_DEC			(16)
#define LUA_MAIN_TEST_DEC		(17)
#define LUA_RESULT_PICK		(1<<0)
#define LUA_FINAL_PICK		(1<<1)
#define LUA_PRESSED_PICK	(1<<2)
#define LUA_TOWATCH_PICK	(1<<3)

#define EVENT_DATA_NONE		0
#define EVENT_TYPE_MOUSE	1
#define EVENT_TYPE_KEY		2
#define EVENT_TYPE_STRING	3
#define EVENT_TYPE_SIZE		4

typedef struct {
	int		nbLevels;
	char	luaFunction[512];
	int		levels[32];
	UnicID	objID[32];
} ObjectEventInfo;

typedef struct ObjectEventDatas_
{
	ObjectEventInfo	*infoPtr;
	int				type;
	char			data[256];
} ObjectEventDatas;


/******************************/
typedef struct SmoothInfos_ {
	float			Rotation;
	float			Translation;
	float			TranslationHold;
	float			Quat;
	float			QuatHold;
} SmoothInfos;

/*******************************/

#define MAX_INPMED		2048 //(!!!!!!!!!!!!!!!!!!!!!!!)
#define MAX_SmallSCenes	1024
#define MAX_PGENERATOR	256
#define MAX_FUR			64

#define MAX_TRACKS 8
#define MAX_SCRIPTS	16

#define MAX_ID 1024 //(!!)
#define MAX_NET_USERS 16

#define ConsoleNumberOfdLines 40

typedef struct LLUA_DBG_STATE_  
{
	char *CompleteFile;
	u32 ulNumberOfLine;

	u32		*LinePasses;
	u32		*TotalLinePasses;
	u32		*LineBreaks[256];
	float	*LineMs;
	float	*LineMsOld;
	u32		*LineMsSort1;
	u32		*LineMsSort2;
	s32 GetTim;
	u32 LastLineNumber; // MAX_STACK
	UNIC_Dico FileNameDicos;


	u32		ModeCall;
	u32		CurrentFile;
	u32		MaxFile;
	u32		HasHooked;
	u32		DeubgTraceMode;
	u32		DeubgThreadID;
	HANDLE	DebugMutex;
	volatile u32 EasySuperLocker;
	volatile u32 LastKeyIn;
	
	u32		CurrentDepth;
	u32		MaxDepth;



	u32		LineToDebug;
	u32		LocalFound;
	char	DEBUG_TEXT[16384];
	char	DEBUG_TOTEST[1024];
	char	AllScriptFileName[256][2048];
	char	CallStack[256][2048];

	bool	showFileList;
	s32		fileListStartDelta;

} LLUA_DBG_STATE;

typedef struct PickingReport_
{
	char	PickingClass[256];
	u32		PickFrozed;
	Vector	PickingCoordUV;
	Vector	PickingCoordXYZ_Local;
	Vector	PickingCoordXYZ_Global;
	MAP		*CollidedMap;
	char	CollidedSmallSceneName[256];
	char	CollidedSmallSceneGameObjectName[256];
	char	CollidedSmallMaterialName[256];
	char	CollidedMediaName[MAX_PATH];
	char	CollidedMediaNickname[256];
	u32		CollidedSmallSceneMaterialIndex;
	s32		GrowCaptureSize;
	u32		AlphaThreshold;
	MATRIX	CurrentGlobalMatrix;
} PickingReport;

#define DEFINE_SCRIPT_SPECIAL(scriptName, functionName, parameters, helpString)
#define DEFINE_SCRIPT(a,params,Help,b) \
	int WSCRIPT_##a(lua_State *L);
#define DEFINE_SCRIPT_REN(n,a,params,Help,b) \
	int WSCRIPT_##n(lua_State *L);
#define DEFINE_SCRIPT_ONLINE(a,params,Help,b,c) \
	int WSCRIPT_##a(lua_State *L);

class WORLD {
public:
	UNIC_Dico		luaLoaddedFilesDICO;
	lua_State *		luaScriptTable[MAX_SCRIPTS];
	char			LuaErrors[1024];
	int				LoadLua(char *filename, BOOL clearAll);
	int				LuaHandle(UINT message, WPARAM wParam, LPARAM lParam);
	int				LuaProcessEvent(int eventNum);
	int				LuaProcessEventDatas(int eventNum, ObjectEventDatas *datas);
	void			LuaEventsExec();
	BOOL			LuaSetLevel(int changeLevel);
	int				LuaScriptManage;
	char			LuaScriptRestart[1024];

#ifdef LUA_DEBUG_MODE
	struct LLUA_DBG_STATE_ *pLDS;
	void			DRawTEXT_BackFull(u8 *pTEXT,u8 *pTEXTHDR,s32 X, s32 Y, u32 CF, u32 CB);
	s32				LUA_DEBUG_BaseDisplay;
	u32				LUA_DEBUG_Flags;
	void			LUA_DEBUG();
	void			LUA_DEBUG_SET_NewFile();
	void			LUA_DEBUG_CLEAN();
	void			LUA_DEBUG_RASTER_START(lua_State *L, lua_Debug *ar);
	void			LUA_DEBUG_RASTER_STOP();
#endif
	void			DRawRaster(u32 Pos, u32 LC, u32 Color , float BeginTimeInMiliSeconds, float TimeInMiliSeconds);
	void			DrawRasters(bool draw);

	BOOL			Xml2Lua(lua_State *L, char *buffer);

#include "Script_commands.h"

	/* All the bitmap MEDIA (WebCam,Avi, Mov, Jpeg, TGA, PSD....) */
	UNIC_Dico		MediaDico;
	u32				WebCamXInvert;
	u32				WebCamYInvert;
	u32				CreateMedia(s8 *Name,u32 ColorMode, bool dummy = false);
	INPUT_IO		*GetMediaFromImage(MAP *IMG);
	void			DestroyMedia(u32 ID, u32 mask = 0);
	INPUT_IO		*ID_MEDIA[MAX_INPMED];
	u32				MediaCreateID;
	void			TouchMedia(char *Name);
	void			DestroyAllMedia();
	u32				*SaveTrackedMedia;
	u32				SaveTrackedMediaSize;
	void			VirtuallyDestroyAllMedia();
	u32				AVIMegaRedirect;
	u32				AVIMegaFPS;
	int				AVIMediaToSave;
	int				GetMediaFromString(char *name, u32 *MediaIndex);
	bool			MediaToScreen(u32 IDMedia, HDC hdcScreen, int sx, int sy, int x=0, int y=0);

	/* Focale */
	float			CurrentFocale;
	float			GetCurrentFocale();
	void			SetCurrentFocale(float focale);
	Vector			Project_2_Screen(Vector V,MAP *RefMap, float focale = 0);


	/* Particule Generator object */
	UNIC_Dico		PGeneratorDico;
	u32				LoadPGenerator(s8 *Name, s8 *fileName, s8 *SceneName, s8 *ObjectName, s8 *MassTextureName);
	void			DeletePGenerator(s8 *Name);
	void			TouchPGenerator(s8 *fileName);
	void			SavePGenerator(s8 *BaseName, s8 *fileName = NULL);
	void			DestroyAllPGenerator();
	PGENERATOR_OBJ	*ID_PGENERATOR[MAX_PGENERATOR];
	u32				PGeneratorCreateID;
	void			ComputeParticleOptions(PGENERATOR_OBJ *PGen);
	void			ProcessParticules(PGENERATOR_OBJ *PGen, bool ProcessOnly = false, float IVal = 0.0f, float JVal = 0.0f, float KVal = 0.0f);
	int				EmitParticule(PGENERATOR_OBJ *PGen, int life = 0, float IVal = 0.0f, float JVal = 0.0f, float KVal = 0.0f, Vector *origin = NULL, Vector *direction = NULL);
	void			RenderParticules(PGENERATOR_OBJ *PGen, char *SceneName);
	u32				ParticuleFromMesh;
	void			ComputeMeshParticules(char *Name, _3D_Object *obj, Mesh *RenderMesh, MATRIX *global);
	int				GetPGeneratorFromString(char *name, u32 *PGeneratorIndex);
	PGENERATOR_OBJ* GetPGeneratorPtrFromString(char *PGeneratorName);

	/* Fur */
	UNIC_Dico		FurDico;
	u32				FurDebug;
	u32				LoadFur(s8 *Name, s8 *fileName, s8 *SceneName, s8 *ObjectName);
	void			DelFurMaterial(FUR_OBJ *Fur);
	void			SetFurMaterial(FUR_OBJ *Fur, char *MatName);
	void			DeleteFur(s8 *Name);
	void			TouchFur(s8 *BaseName);
	void			SaveFur(s8 *Name, s8 *fileName = NULL, u32 fullPath = 0);
	void			ComputeFurOptions(FUR_OBJ *Fur);
	FUR_OBJ			*ID_FUR[MAX_FUR];
	u32				FurCreateID;
	void			ComputeMeshFur(char *Name, _3D_Object *obj, Mesh *RenderMesh, MATRIX *global);
	void			RenderFur(FUR_OBJ *Fur, char *SceneName);
	int				GetFurFromString(char *name, u32 *FurIndex);
	FUR_OBJ			*GetFurPtrFromString(char *FurName);


	/* Ini files to save and load information */
	UNIC_Dico		IniFileDico;
	#define			MAX_INIFILES	512
	INIFILE			IniFiles[MAX_INIFILES];			
	u32				LoadIniFile(char *fileName, int forceCreate = 0);
	u32				SaveIniFile(char *fileName);
	u32				DestroyIniFile(char *fileName);
	bool			GetIniValue(char* iniFilename, char* iniVarname);
	bool			GetIniValue(char* iniFilename, char* iniVarname, char* iniValueDest);
	bool			GetIniValue(char* iniFilename, char* iniVarname, char* iniVarDefaultValue, char* iniValueDest);
	bool			SetIniValue(char* iniFilename, char* iniVarname, char* newValue);


	/* Collision */	
	UNIC_Dico		CollisionDico;
	u32				CollisionCreateID;
	u32				CollisionOn;
	void			ComputeCollision(char *Name, int objIdx, Mesh *RenderMesh, MATRIX objGlobal);


	/* All the 3D objects */
	Vector			*ComputingBuffer;
	u32				ComputingBufferSize;
	Vector			*ComputingBuffer2;
	u32				ComputingBufferSize2;
	Vector			*ComputingBuffer_UV;
	u32				ComputingBufferSize_UV;
	Vector			*ComputingBuffer_Normales;
	u32				ComputingBufferSize_Normales;
	UNIC_Dico		SmallSceneDico;
	u32				SmScCreateID;
	SmallScene		*pSmallScenes[MAX_SmallSCenes];
	u32				AnimCreateID;
	UNIC_Dico		AnimDico;
	SmallScene_ANIM *pAllAnims;
	u32				ulForceWireFrame;
	_3D_Object		**pRenderDrawSort;
	u32             RenderDrawSortNumberMax;

	void			RestoreAllSmallScene(BOOL onlyIK);
	u32				RenderSmallScene(char *Name,u32 Mode = 0); // 0 = Normal , 1 = Reversze , 2 = Z Pass
#define ReverseRenderSmallScene(a) RenderSmallScene(a,1);
	void			RenderTriangle(SmallScene *SmSc, int MediaIndex, Vector *A, Vector *B, Vector *C, Vector *UV1, Vector *UV2, Vector *UV3, int BlendMode);

	void			GetBVSon(MATRIX *matrix, Vector *BVSonMin, Vector *BVSonMax);
	u32				GetSmScSize(SmallScene *Ret);
	void			ComputeSkinning(SmallScene *SmSc,Mesh *RenderMesh,MATRIX *InverseRootMat,u32 ModeInverse = 0);
	void			ComputeMorphing(SmallScene *SmSc,Mesh *RenderMesh );
	void			ComputeSmallSceneHierarchie(SmallScene *SmSc,u32 ObjectIndex = -1);
	void			ComputeSmallSceneHierarchie_Local(SmallScene *SmSc,u32 ObjectIndex = -1);
	void			ComputeSmallSceneBV(SmallScene *SmSc);
	void			ComputeSmallSceneObjectLookAt(SmallScene *SmSc,u32 Affect,u32 ObjectIndex,u32 ObjectRefLA = -1);
	void			ComputeSmallSceneIK(SmallScene *SmSc,u32 Instance);
	void			ComputeLocalMatrixes_IK(SmallScene *SmSc);
	void			DrawSmallSceneIK(SmallScene *SmSc);
	SmallScene		*SmallNameToScene(char *Name);
	void			ComputeLastSon(SmallScene *SmSc);
	void			SmallScene_HideObject(SmallScene *SmSc,u32 ObjectIndex,u32 Hide, u32 AffectChildren = 1);
	void			SmallScene_RestoreInitialPosition(SmallScene *SmSc,u32 ObjectIndex = 0);
	void			SmallScene_ObjectStateSave(SmallScene *Smsc, u32 objectIndex, int index, DWORD stateMask);
	s32				SmallScene_ObjectStateRestore(SmallScene *Smsc, u32 objectIndex, int index, DWORD stateMask);
	void			SmallScene_ObjectStateFree(SmallScene *Smsc, int index);
	char			*SmallScene_EnumMaterials(SmallScene *SmSc, int *nbElmts);
	char			*SmallScene_EnumMedia(SmallScene *SmSc, int *nbElmts);
	void			SetSmoothMatrix(int smoothNumber, MATRIX *TMatrix, int Affect, int axeInversion = 0);
	void			AffectTrackMatrixToSmallScene(int smoothNumber, SmallScene *SmSc,u32 Affect,MATRIX *pTrckMatrix);
	void			AffectTrackSubMatrixToSmallScene(int smoothNumber, SmallScene *SmSc, char *ObjName,u32 Affect,MATRIX *pTrckMatrix, int axeInversion);
	void			AffectTrackScaleToSmallScene(SmallScene *Smsc,Vector *Scale);
	void			MoveSceneCamera(int smoothNumber, SmallScene *Smsc, int Affect, IDFX *idFX);
	int				MediaSetMatrix(SmallScene *SmSc,u32 MediaIndex,u32 TrackNum, u32 status, u32 useTimeLineCorrection);
	_3D_Material	*MaterialNameToMaterial(SmallScene	*Smsc, char *Name);
	int				ConcatMaterial(char *SmscName, char *MatName, char *SmscNameToAdd, char *MatToAddName);
	int				SaveMaterial(_3D_Material *Mat, char *SmscName, char *MatName);
	int				LightNameToIndex(SmallScene	*Smsc, char *LightName);
	int				LoadSmSc(char *Name);
	void			ReLoadSmSc(SmallScene *SmSc);
	int				LoadAnim(char *AnimName,char *SmScName = NULL, int ForceReload = 0);
	int				PlayAnim(char *AnimName,char *SmScName,s32 Time,float BlendFactor);
	void			DestroyAnim(char *AnimName,char *SmScName = NULL);
	void			DestroyAllAnim();

	void			TouchSmallScene(char *Name);
	void			DeleteSmSc(char *smallSceneName);
	void			DestroySmSc(SmallScene *Ret);
	void			DestroyAllSMSC();
	DrawInterface	*DI;
	void			ChangeDriver(u32 NewIndex);

	/* MAX INTERFACE */
#define SMALLSCENE_MAX
	Mesh *			SmallSceneGetMesh(char *NameSmSC,char *ObjectName);
	int				SmallSceneNew(char *NameSmSC);
	void			SmallSceneNewObject(char *NameSmSC,char *ObjectName,char *ObjectFather, MATRIX *objPos);
	int				SmallSceneNewMesh(char *NameSmSC,char *ObjectName);
	int				SmallSceneNewMaterial(char *NameSmSC,char *MaterialName,u32 SmallSceneNewMaterial = -1);
	int				SmallSceneLinkObjectMaterial(char *NameSmSC,char *ObjectName,char *MaterialName);
	int				SmallSceneNewMultiMaterial(lua_State *L);
	int				SmallSceneLinkObjectMultiMat(char *NameSmSC,char *ObjectName,char *MultiMatName);
	int				SmallSceneNewLight(char *NameSmSC, char *LightName,char *ObjectName);
	int				SmallSceneIKReset(char *NameSmSC);
	void			SmallSceneIKInstancesReset(char *NameSmSC);
	void			SmallSceneIKInstancesReset(SmallScene *SmSc);

	/* Link Object */
	int AffectObjectToVertex(SmallScene *Smsc, int index, char *ObjectNameSrc, char *ObjectNameDst, bool force);
	int ObjectLinkSnap(SmallScene *Smsc, char *DummySnapSrc, char *DummySnapDst);
	int ObjectLinkScale(SmallScene *Smsc, char *DummySnapSrc1, char *DummySrc2, char *DummySnapDst1, char *DummyDst2, int axe, u32 mode);
	Vector GetScaleVector(MATRIX *SrcMatrix, Vector *SrcDummy,  MATRIX *DstMatrix, Vector *DstDummy, int axe, u32 mode);

	/* Picking Info */
	u32				CaptureMode;

	PickingReport	PickReportClick;	// for event handling
	PickingReport	PickReportCurrent;

	PickingReport	PickReportResult;	// last current pick
	PickingReport	PickReportFinal;	// saved result if no capture
	PickingReport	PickReportToWatch;	// always saved result 

	
	/* Smooth Params */
	float			FrmFactorRotation;
	float			FrmFactorTranslation;
	float			FrmFactorRotationLimit;
	float			FrmQuatMode;
	
	SmoothInfos		FrmSmooth;

	/* TRACK EDITOR */
	TrackPlayer		*pTrack; // When this is not null, track editor is enable. (The current ID 0 animation is saved)

	/* Network Object */
#ifndef SKIMMED_NET
	NET_IO			*NetObj;
#endif
	u32				MustEncodeFromScratch;
	u32				ConnectedMask;
	u32				ConnectedNumber;
	

	/* Flash communication */
	u32				FlashthreadID;
	HANDLE			FlashthreadHandle;
	struct FlashCom_ *pFC;
	SOCKET			FlashClient;
	void			FlashCom_Init();
	void			FlashCom_OneFrame();
	void			FlashCom_Send(char *Text, int client = -1);
	void			FlashCom_Destroy();

	/* Command scripts */
	char			ScriptNameStack[MAX_SCRIPTS][2048];
	int				currentScript;
	HANDLE			ScriptAccesMutex;
	CommandBatch	SceneScript_Loop;
	CommandBatch	SceneScript_Ecluse;
	u32				SceneScript_INIT();
	u32				SceneScript_ADD(CommandBatch *SceneScript, char *Line, u32 Index = -1);
	u32				SceneScript_DESTROY(CommandBatch *SceneScript,u32 Index = -1);
	u32				SceneScript_SetText(CommandLine *CL, char *Line);
	u32				SceneScript_EXECUTE();
	
	/* Output MAP */
	void			SetOutputFormat(u32 SizeX,u32 SizeY);
	u32				GetOutput();


	/* Scene Manager */
	u32				XSize,YSize;
	float			fResQualityFactor;
	u32				MediaToTrack;
	u32				TrackRes;
	HWND			OwnerHwnd;
	HDC				hdcCompatible; 
	HBITMAP			hbmScreen; 
	HRGN			wndRegion;

	u32				UseGDI;	
	u32				LayederWindow;	

	u32				ulMustUpdateFrameBufferResult;
	u32				ulFullRefresh;

	MAP				FrameBufferResult;
	u32				RenderingCounter;
	u32				MediaCurrentTrack;
	
	int				FrameBufferMediaDiff;
	int				RegionThreshold;
	u32				MosaicInfo;

	void			FrameCall();
	void			RenderFlip();
	void			Flip_DIB(bool clearDI = true);
	void			Reset_All();

	BOOL			forceAdVisibility;

	WORLD()			
	{
		memset(this,0,sizeof(*this));
#ifdef WIIMOTE_SUPPORT
		remote = new wiimote[4];
#endif

	}
	void			OutputConsole(char *String);
	void			ChangeResolution(u32 NewSizeX,u32 NewSizeY);
	void			ReadFrameBuffer();
	void			ChangeGDIMode(u32 useGDI);
	void			DrawConsole();
	void			ClearConsole();
	void			Mosaique();
	Vector			ScreenPointToScene(SmallScene *Smsc, Vector screenPoint);
	Vector			ScenePointToScreen(SmallScene *Smsc, Vector ScenePoint);

	/* Material Overload */
	_3D_MaterialLayer	MaterialOr;
	_3D_MaterialLayer	MaterialAnd;
	void			ResetMaterialOverload() { memset(&MaterialOr , 0 , sizeof(_3D_MaterialLayer));memset(&MaterialAnd , 0xff , sizeof(_3D_MaterialLayer)); };

	/* Watcher Flags */
#define MAD_AUTO_RELOAD 1
#define LUA_AUTO_RELOAD 2
	u32				WFlags;

	CFast2D			fast2D;
	/* Trackeur Management*/
	HeadDetector	headDetector;
	struct TRACK_OneFrameCall_Parrams_ *ParramT;
	WORKINGSPACE	*WSPC;
	void			DestroyTrackeur();
	IDFX			*ID_TABLE[MAX_ID];
	u32				ForceTraking;
	u32				NumberOfID;
	u32				CurrentID;
	u32				TRACK_OneFrameCall(MAP &SOURCEMAP,MAP *ZMAP);
	u32				TRACK_Synchronise_Multithread(); 
	u32				trackSize;
	u32				ulSkippedFrameCounter;
	u32				trackMiliseconds_x_16;

	void			ID_NewAnimated(u32 ID,u32 MediaSourceIndex,u32 MediaSubTrackIndex);
	u32				ID_New(int ID = -1);
	void			ID_SelectMesh(u32 ID , u32 Mesh);
	void			ID_SetMesh(u32 ID , Mesh *NewMesh);
	void			ID_SetScale(u32 ID , Vector *pNewScale);
	void			ID_SetHaarParrams(u32 ID , Vector *pNewScale);
	void			ID_SetDebugInfo(u32 ID,u32 DisplayTextInfos , u32 DisplayTrackedMeshes);
	void			ID_ResetAll();
	void			ID_Reset(u32 ID);
	void			ID_Destroy(u32 ID);
	void			ID_AutoStart(u32 ID);
	void			ID_Load		(u32 ID , char *FileName);
	void			ID_Save		(u32 ID , char *FileName);
	u32				ID_GetMatrix(u32 ID , float *XYZ_IJKT);
	u32				ID_SetMatrix(u32 ID , float *XYZ_IJKT);
	void			ID_Boot(u32 ID );
	void			ID_SetName	(u32 ID , char *Name);
	u32				VALIDATE_ID(u32 ID);


	/* Sounds */
	MicroIn			microIn;
	MicroOut		microOut;

	/* Paint */
	void			RenderText(unsigned char *Txt,float X, float Y, float FX, float FY , u32 ColorRGBA, char *font, int blendingMode = -1);
	void			GetTextSize(unsigned char *Txt,POINT *OutSize, char *font);
	void			GetTextPoint(POINT *InPoint,POINT *OutPoint, char *font);


	void			Paint(MAP *source, POINT pt, POINT prevPt, u32 RGB, int opacity, int len);
	void			PaintCursor(MAP *source, POINT pt, int len);
	void			DrawSquare(MAP *source, int x, int y, int sx, int sy, u32 RGB, int Opacity, int Diam, int Filled, float Angle);
	void			DrawSquareInLine(MAP *source, POINT pt, POINT prevPt, int sx, int sy, u32 RGB, int Opacity, int Diam, int Filled, float Angle, float previousAngle);
	MAP				PaintBuffer;
	BOOL			prevMousePointSet;
	POINT			prevMousePoint; // 0
	float			prevAngle;
	int				prevDiam;
	u32				ulLockMode;

	BOOL			SaveTGA(char *fileName, MAP *source, MAP *alpha = NULL);

	/* User interface */
	bool			hasFocus;
	char			CurrentlyEditedText[2048];
	DrwTEXT_UI		D_UI;
	TEXT_Grabber	*pTG;
	int				ProcessSel(char *NewString);
	int				InputHook(UINT message , LPARAM wParam, LPARAM lParam);
	int				GetTextFocus(TEXT_Grabber	*pTGTS);
	int				LooseFocus();
	void			InputHookPickEnd();
	int				UpdateText();

	DWORD			SkipFunctions;
	int				WMPaintLayer;

	char			LastKeyPressed;
	u32				KeyPressed[8];
	BOOL			MouseButton; // 1
	s32				MouseX,MouseY;
	u32				bDrawRasters;
	u32				bDrawConsole;
	u32				bShowSceneInfo;
	u32				bManualBoot;
	u32				oldManualBoot;
	u32				bDrawSound;

	u32				IsKeyPressed(unsigned char A) {A=Upper(A);return KeyPressed[A>>5] & (1<<(A&31));};
	void			PressKey(unsigned char A) {LastKeyPressed=A; A=Upper(A);KeyPressed[A>>5] |= (1<<(A&31));};
	void			UnPressKey(unsigned char A) {LastKeyPressed=0; A=Upper(A);KeyPressed[A>>5] &= ~(1<<(A&31));};

#ifdef WIIMOTE_SUPPORT
	/* Wiimote *********************/
	wiimote			*remote;
#endif

	/* Pack - unpack interface */
	UNIC_Dico		PackFileDico;
	UNIC_Dico		PackFileDicoNeredondance;
	u32				PackFileCrypt;

	u32 AddFileToPack(char *Filname);
	u32 PACK(char *Filname, u32 AllLoadedMediaSCENE);
	u32 UNPACK(char *Filname,u32 LAUCHLUA,u32 OverrideMode, bool deleteTarget=false, volatile const bool *Aborted=NULL); 
	char** GETZCCFILES(char *Filname, int *nbElmts);
	u32 PACK_ADDREFFILE(char *Filname); 
	u32 PACK_ADDREFSCENE(char *SCENEname);

};

WORLD *CreateWORLD(u32 SizeX,u32 SizeY, char *iniFile = NULL);
extern int DW_WatchDirectory(char *DirectoryToWatch,void *Callback(void *,char *),void *);


#endif