#include "SCENE.H"

/****************************************************************************************************************/
/****************************************************************************************************************/
/* Material IO																									*/
/****************************************************************************************************************/
/****************************************************************************************************************/

#define RSBASIC_EXPORT(A,NAME)\
{\
	u32 Value;\
	Value = A;\
	ReadSave_String_Const(IO,NAME);\
	ReadSave_U8(IO,(u8*)&Value);\
	A = Value;\
}

void ReadSave_RenderState(IO_STRUCT *IO,RS *Address,u32 Version)
{
	READSAVE_ENTRY();
	ReadSave_String_Const(IO,"RenderSTATE");
	RSBASIC_EXPORT(Address->WIRED			,"wired");
	RSBASIC_EXPORT(Address->BACKFACE		,"backface");
	RSBASIC_EXPORT(Address->BACKFACE_INVERT	,"backface invert");
	RSBASIC_EXPORT(Address->NOZWRITE		,"no z write");
	RSBASIC_EXPORT(Address->NOZTEST			,"no z test");
	RSBASIC_EXPORT(Address->TEXTURED		,"textured");
	RSBASIC_EXPORT(Address->HIDECOLOR		,"hide color");
	RSBASIC_EXPORT(Address->HIDEALPHA		,"hide alpha");
	RSBASIC_EXPORT(Address->SECONDPASS		,"secondpass");

	
	if (Version >= 1)
	{
		ReadSave_String_Const(IO,"UVMatrix");
		ReadSave_FLOAT(IO,Address->UVMATRIX,6);
	} else
	{
		Address->UVMATRIX[0] = Address->UVMATRIX[3] = 1.0f;
		Address->UVMATRIX[4] = Address->UVMATRIX[5] = 0.0f;
		Address->UVMATRIX[1] = Address->UVMATRIX[2] = 0.0f;
	}
	if (Version >= 2)
	{
		ReadSave_String_Const(IO,BLENDING_MODES);
		ReadSave_U8(IO,(u8*)&Address->BlendingMode);
	} else
		Address->BlendingMode = 0;

	if (Version >= 3)
	{
		ReadSave_String_Const(IO,MAPPING_MODES);
		ReadSave_U8(IO,(u8*)&Address->MappingMode);
	} else
		Address->MappingMode = 0;

	if (Version >= 7)
	{
		RSBASIC_EXPORT(Address->INVERTALPHA		,"InvertAlpha");
	} else
		Address->INVERTALPHA = 0;

	if (Version >= 12)
	{
		ReadSave_String_Const(IO,"Alpha threshold");
		ReadSave_U8(IO,(u8*)&Address->AlphaThreshold);
	} else
		Address->AlphaThreshold = 0;

	if (Version >= 13)
	{
		RSBASIC_EXPORT(Address->LIGHTED	,"Lighted");
	} else
		Address->LIGHTED = 1;

	if (Version >= 15)
	{
		RSBASIC_EXPORT(Address->PICKABLE ,"Pickable");
	} else
		Address->PICKABLE = 1;
	if (Version >= 16)
	{
		RSBASIC_EXPORT(Address->PICKABLE_NO_TRANSPARENCY ,"Pickable no transparency");
	} else
		Address->PICKABLE_NO_TRANSPARENCY = 0;

	if (Version >= 17)
	{
		RSBASIC_EXPORT(Address->SKIPLAYER ,"Skip this layer");
	} else
		Address->SKIPLAYER = 0;

	if (Version >= 18)
	{
		RSBASIC_EXPORT(Address->TEXTUREREPEAT_U ,"Texture repeat U");
		RSBASIC_EXPORT(Address->TEXTUREREPEAT_V ,"Texture repeat V");
	} else
	{
		Address->TEXTUREREPEAT_U = 1;
		Address->TEXTUREREPEAT_V = 1;
	}
	if (Version >= 20)
	{
		RSBASIC_EXPORT(Address->ZEQUAL,"Z test equal only");
	} else
	{
		Address->ZEQUAL = 0;
	}


	if (Version >= 14)
	{
		ReadSave_String_Const(IO,"Normal Extraction");
		ReadSave_FLOAT(IO,(float*)&Address->NormalExtraction);
	} else
		Address->NormalExtraction = 0.0f;

	if (Version >= 21)
	{
		RSBASIC_EXPORT(Address->USEVERTEXCOLORS,"Use vertex colors");
	} else
		Address->USEVERTEXCOLORS = 0;

	if (Version >= 22)
	{
		RSBASIC_EXPORT(Address->TEXTUREBILINEAR,"Use bilinear filtering");
	} else
		Address->TEXTUREBILINEAR = 1;

	if (Version >= 23)
	{
		ReadSave_String_Const(IO,"Anim Number on images on X");
		ReadSave_U16(IO,&Address->AnimNbX);
		ReadSave_String_Const(IO,"Anim Number on images on Y");
		ReadSave_U16(IO,&Address->AnimNbY);
		ReadSave_String_Const(IO,"Anim FPS");
		ReadSave_FLOAT(IO,(float *)&Address->AnimFPS);
	} else
	{
		Address->AnimNbX = 1;
		Address->AnimNbY = 1;
		Address->AnimFPS = 0;
	}
}

u32 _3D_Material_LoadSave(IO_STRUCT *IO,_3D_Material *Mat)
{
	CHECK_VERSION(23);

	if (IO->Dico == NULL) return IO_FAIL(IO);

	if (Version == 8) ReadSave_String_Const(IO,"BEGIN LAYER ********************************************************************");

	ReadSave_String_Const(IO,"TEXTURE LAYERS NUM");
	ReadSave_U32(IO,&Mat->NumberOfLayers);
	for (int i = 0 ; i < Mat->NumberOfLayers ; i++)
	{
		char TextureName[2048];
		if (Version >= 9) ReadSave_String_Const(IO,"BEGIN LAYER **********************************************************************************************************************");
		/* Export Name <=> Import ID */
		ReadSave_Name(IO,&Mat->Layers[i].TextureID,"TEXTURE NAME");
		/* Renderstate */
		ReadSave_RenderState(IO,&Mat->Layers[i].RenderState,Version);
		/* ColorMul */
		ReadSave_String_Const(IO,"COLOR MULTIPLIER RGBA");
		if (Version > 3)
			ReadSave_U8(IO,(unsigned char *)&Mat->Layers[i].ColorMultiplier,4);
		else
			Mat->Layers[i].ColorMultiplier = 0xffffffff;

		/* Layername */
		if (Version > 18)
		{
			char SafeRead[2048];
			Mat->Layers[i].LayerName[255] = 0;
			strcpy((s8*)SafeRead , (s8*)Mat->Layers[i].LayerName );
			ReadSave_String_Const(IO,"Layer name");
			ReadSave_String(IO,(s8*)SafeRead);
			SafeRead[255] = 0;
			strcpy((s8*)Mat->Layers[i].LayerName , (s8*)SafeRead );
		} else
		{
			sprintf((s8*)Mat->Layers[i].LayerName,"Layer %d" , i  );
		}


	}

	if (Version == 8) ReadSave_String_Const(IO,"END LAYER ********************************************************************");


	CHECK_END();
}

DECLARE_IO_C(_3D_Material);

/****************************************************************************************************************/
/****************************************************************************************************************/
/* _3D_Object IO																										*/
/****************************************************************************************************************/
/****************************************************************************************************************/
u32 _3D_Object_LoadSave(IO_STRUCT *IO,_3D_Object *OBJ)
{
	char Name[2048];

	CHECK_VERSION(3);

	if (IO->Dico == NULL) return IO_FAIL(IO);
	/* Export Name <=> Import ID */
	ReadSave_Name(IO,&OBJ->FatherID,"PARENT NAME");
	ReadSave_Name(IO,&OBJ->MeshID,"MESH NAME");
	ReadSave_Name(IO,&OBJ->MaterialID,"MATERIAL NAME");
	ReadSave_Name(IO,&OBJ->MultiMaterialID,"MULTIMATERIAL NAME");

	ReadSave_String_Const(IO,"GlobalMatrix");
	ReadSave_Matrix(IO,&OBJ->GlobalMatrix);
	ReadSave_String_Const(IO,"LocalMatrix");
	ReadSave_Matrix(IO,&OBJ->LocalMatrix);

	if (Version >= 1)
	{
		ReadSave_String_Const(IO,"Pivot");
		ReadSave_Vector(IO,&OBJ->Pivot);
		if (Version >= 2)
		{
			ReadSave_String_Const(IO,"ObjectName");
			Signify_Ptr(IO,(void**)&OBJ->pObjectName, 128);
			ReadSave_String(IO,(char*)OBJ->pObjectName);
		} else OBJ->pObjectName = 0;
	
	} else
		OBJ->Pivot = Vector(0,0,0);

	if (Version >= 3)
	{
		ReadSave_String_Const(IO,"Object Draw order");
		ReadSave_S32(IO,(s32*)&OBJ->DrawOrder);
	} else
		OBJ->DrawOrder = 0;
	CHECK_END();
}

DECLARE_IO_C(_3D_Object);


/****************************************************************************************************************/
/****************************************************************************************************************/
/* _3D_MultiMaterial IO																										*/
/****************************************************************************************************************/
/****************************************************************************************************************/
u32 _3D_MultiMaterial_LoadSave(IO_STRUCT *IO,_3D_MultiMaterial *OBJ)
{
	char Name[2048];

	CHECK_VERSION(0);

	if (IO->Dico == NULL) return IO_FAIL(IO);
	/* Export Name <=> Import ID */
	ReadSave_String_Const(IO,"Multimaterial number");
	ReadSave_U32(IO,&OBJ->ulNumberOfMaterials);
	Signify_Ptr(IO,(void**)&OBJ->pMaterialsIDS,sizeof(UnicID) * OBJ->ulNumberOfMaterials);
	Signify_Ptr(IO,(void**)&OBJ->pMaterialsIndexes,sizeof(u32) * OBJ->ulNumberOfMaterials);
	ReadSave_Name(IO,OBJ->pMaterialsIDS,"Material NAME",OBJ->ulNumberOfMaterials);
	CHECK_END();
}

DECLARE_IO_C(_3D_MultiMaterial);

/****************************************************************************************************************/
/****************************************************************************************************************/
/* _3D_Light IO																										*/
/****************************************************************************************************************/
/****************************************************************************************************************/
u32 _3D_Light_LoadSave(IO_STRUCT *IO,_3D_Light *OBJ)
{
	char Name[2048];

	CHECK_VERSION(4);

	if (IO->Dico == NULL) return IO_FAIL(IO);
	/* Export Name <=> Import ID */
	ReadSave_String_Const(IO,"Light Type (Omni 0 ,Spot 1,Direct 2,Ambient 3)");
	ReadSave_U32(IO,&OBJ->LightType);
	ReadSave_String_Const(IO,"Near");
	ReadSave_FLOAT(IO,&OBJ->Near);
	ReadSave_String_Const(IO,"Far");
	ReadSave_FLOAT(IO,&OBJ->Far);
	ReadSave_String_Const(IO,"SmallAlpha");
	ReadSave_FLOAT(IO,&OBJ->SmallAlpha);
	ReadSave_String_Const(IO,"BigAlpha");
	ReadSave_FLOAT(IO,&OBJ->BigAlpha);
	if (Version <= 2)	ReadSave_String_Const(IO,"Light color");
	if (Version == 0)
	{
		u32 Dummy;
		ReadSave_Color(IO,&Dummy);
		OBJ->LightColor.x = (float)(Dummy & 0xff) / 255.0f;
		OBJ->LightColor.y = (float)((Dummy>>8) & 0xff) / 255.0f;
		OBJ->LightColor.z = (float)((Dummy>>16) & 0xff) / 255.0f;
		OBJ->IsOn = 1;
	}
	if (Version >= 1)
	{
		ReadSave_String_Const(IO,"light Color");
		ReadSave_Vector(IO,&OBJ->LightColor);
		ReadSave_String_Const(IO,"light switch on/off");
		ReadSave_U32(IO,&OBJ->IsOn);
	}

	ReadSave_Name(IO,&OBJ->ObjectID,"Owner Object");

	CHECK_END();
}

DECLARE_IO_C(_3D_Light);

/****************************************************************************************************************/
/****************************************************************************************************************/
/* _3D_MultiMaterial IO																										*/
/****************************************************************************************************************/
/****************************************************************************************************************/
u32 TrackPlayer_LoadSave(IO_STRUCT *IO,TrackPlayer *OBJ)
{
	IO->LSD &= ~LSD_TEXT;
	CHECK_VERSION(4);
	if (Version >= 3)
	{
		ReadSave_String_Const(IO,"Descriptor Number");
		ReadSave_U32(IO,&OBJ->ulNumberOfDescriptors);
		Signify_Ptr(IO,(void**)&OBJ->DescriptorsPtrs,sizeof(TrackPlayer_Descriptors) * OBJ->ulNumberOfDescriptors);
		for (int i = 0; i < OBJ->ulNumberOfDescriptors; i ++)
		{
			ReadSave_String_Const(IO,"Marker");
			ReadSave_U32(IO,&OBJ->DescriptorsPtrs[i].ImageMarker);
			ReadSave_String_Const(IO,"Focale");
			ReadSave_FLOAT(IO,&OBJ->DescriptorsPtrs[i].CurrentFocal);
			ReadSave_String_Const(IO,"Flags");
			ReadSave_U32(IO,&OBJ->DescriptorsPtrs[i].Flags);
			if (Version >= 4)
			{
				ReadSave_String_Const(IO,"Descriptor Data Index");
				ReadSave_U32(IO,(u32 *)&OBJ->DescriptorsPtrs[i].DataIndex);
			}
		}
	}
	ReadSave_String_Const(IO,"Tracks Number");
	ReadSave_U32(IO,&OBJ->ulNumberOfTracks);
	Signify_Ptr(IO,(void**)&OBJ->TracksPtrs,sizeof(TrackPlayer_Stream) * OBJ->ulNumberOfTracks);
	if (OBJ->ulNumberOfTracks)
	{
		for (int i = 0; i < OBJ->ulNumberOfTracks ; i ++)
		{
			ReadSave_String_Const(IO,"Track name");
			ReadSave_String(IO,OBJ->TracksPtrs[i].Name);
			if (Version >= 1)
			{
				ReadSave_String_Const(IO,"Track Scale");
				ReadSave_Vector(IO,&OBJ->TracksPtrs[i].Scale);
			} else
				OBJ->TracksPtrs[i].Scale = Vector(1,1,1);
			ReadSave_String_Const(IO,"Number of matrixes");
			ReadSave_U32(IO,&OBJ->TracksPtrs[i].ulNumberOfMC);
			Signify_Ptr(IO,(void**)&OBJ->TracksPtrs[i].pAnimation,sizeof(MatrixCompressed) * (OBJ->TracksPtrs[i].ulNumberOfMC +256 /* See trackplayer.cpp for details about "+256" */));
			for (int j = 0 ; j < OBJ->TracksPtrs[i].ulNumberOfMC ; j++)
			{
				ReadSave_String_Const(IO,"Compressed matrix:");
				ReadSave_Quat(IO,&OBJ->TracksPtrs[i].pAnimation[j].Rot);
				ReadSave_Vector(IO,&OBJ->TracksPtrs[i].pAnimation[j].Trans);
				ReadSave_String_Const(IO,"Flag");
				ReadSave_U32(IO,&OBJ->TracksPtrs[i].pAnimation[j].IsValid);
				if (Version >= 2)
				{
					u32 DUMMY;
					ReadSave_String_Const(IO,"SkinCol");
					ReadSave_U32(IO,&OBJ->TracksPtrs[i].pAnimation[j].SkinColor);
					if (Version == 2)
					{
						ReadSave_String_Const(IO,"Marker");
						ReadSave_U32(IO,&DUMMY);
					}
					if (Version >= 4)
					{
						ReadSave_String_Const(IO,"Track Data Index");
						ReadSave_U32(IO,(u32 *)&OBJ->TracksPtrs[i].pAnimation[j].DataIndex);
					} else
					{
						OBJ->TracksPtrs[i].pAnimation[j].DataIndex = -1;
					}
				} else
				{
					OBJ->TracksPtrs[i].pAnimation[j].SkinColor = 0;
				} 
			}
		}
	}
	if (Version >= 4)
	{
		ReadSave_String_Const(IO,"Data Info Number");
		ReadSave_U32(IO,&OBJ->Datas.ulNumberOfInfos);
		Signify_Ptr(IO,(void**)&OBJ->Datas.InfosPtr,sizeof(TrackPlayer_DataInfo) * OBJ->Datas.ulNumberOfInfos);
		for (int i = 0; i < OBJ->Datas.ulNumberOfInfos; i ++)
		{
			ReadSave_String_Const(IO,"Data Info Name");
			ReadSave_String(IO,OBJ->Datas.InfosPtr[i].Name);
			ReadSave_String_Const(IO,"Data Info Type");
			ReadSave_U32(IO,(u32 *)&OBJ->Datas.InfosPtr[i].DataType);
		}
		ReadSave_String_Const(IO,"Data Info Cells");
		ReadSave_U32(IO,&OBJ->Datas.ulNumberOfCells);
		Signify_Ptr(IO,(void**)&OBJ->Datas.CellsPtr,sizeof(TrackPlayer_DataCell) * OBJ->Datas.ulNumberOfCells);

		ReadSave_String_Const(IO,"Data Info Empty Cells");
		ReadSave_U32(IO,(u32 *)&OBJ->Datas.EmptyCellList);

		for (int i = 0; i < OBJ->Datas.ulNumberOfCells; i ++)
		{
			ReadSave_String_Const(IO,"Data Cell Stream");
			ReadSave_U32(IO,(u32 *)&OBJ->Datas.CellsPtr[i].TrackStream);
			ReadSave_String_Const(IO,"Data Cell Pos");
			ReadSave_U32(IO,(u32 *)&OBJ->Datas.CellsPtr[i].TrackPos);
			ReadSave_String_Const(IO,"Data Cell Info Index");
			ReadSave_U32(IO,(u32 *)&OBJ->Datas.CellsPtr[i].DataNameIdx);
			ReadSave_String_Const(IO,"Data Cell Value Len");
			ReadSave_U32(IO,(u32 *)&OBJ->Datas.CellsPtr[i].ValueLen);
			if (OBJ->Datas.CellsPtr[i].DataNameIdx == -1 ||
				OBJ->Datas.InfosPtr[OBJ->Datas.CellsPtr[i].DataNameIdx].DataType == TRK_DATA_EMPTY)
			{
				ReadSave_String_Const(IO,"Data Cell Value");
				OBJ->Datas.CellsPtr[i].ValueInt = 0;
				ReadSave_U32(IO,(u32 *)&OBJ->Datas.CellsPtr[i].ValueInt);
			} else {
				ReadSave_String_Const(IO,"Data Cell Value");
				switch (OBJ->Datas.InfosPtr[OBJ->Datas.CellsPtr[i].DataNameIdx].DataType)
				{
				case TRK_DATA_INT:
					ReadSave_U32(IO,(u32 *)&OBJ->Datas.CellsPtr[i].ValueInt);
					break;
				case TRK_DATA_FLOAT:
					ReadSave_FLOAT(IO,&OBJ->Datas.CellsPtr[i].ValueFloat);
					break;
				case TRK_DATA_STR:
					Signify_Ptr(IO,(void**)&OBJ->Datas.CellsPtr[i].ValueStr, OBJ->Datas.CellsPtr[i].ValueLen);
					ReadSave_String(IO,OBJ->Datas.CellsPtr[i].ValueStr);
					break;
				}
			}
			ReadSave_String_Const(IO,"Data Cell Prev");
			ReadSave_U32(IO,(u32 *)&OBJ->Datas.CellsPtr[i].PrevCell);
			ReadSave_String_Const(IO,"Data Cell Next");
			ReadSave_U32(IO,(u32 *)&OBJ->Datas.CellsPtr[i].NextCell);
		}
	}
	CHECK_END();
}
DECLARE_IO_C(TrackPlayer);
/****************************************************************************************************************/
/****************************************************************************************************************/
/* SmallScene IK IO																								*/
/****************************************************************************************************************/
/****************************************************************************************************************/

void ReadSave_Name_Index(IO_STRUCT *IO,UnicID *Address,char *Descriptor = NULL, u32 Count = 1)
{
	READSAVE_ENTRY();
	for (int i = 0; i < Count ; i ++)
	{
		char Name[2048];
		if (Descriptor) ReadSave_String_Const(IO,Descriptor);
		IO->Dico->GetName(Address,(char*)Name);
		ReadSave_String(IO,Name);
		IO->Dico->GetUnic(Address,(char*)Name);
		IO->Dico->mpst_Dico[*Address].AssociatedValue = i;
		Address ++;
	}
}

u32 SmallScene_IK_LoadSave(IO_STRUCT *IO,SmallScene_IK *OBJ)
{
	char Name[2048];

	CHECK_VERSION(3);

	ReadSave_String_Const(IO,"!! Flags Value : 0 = inactive ; 1 = active ; 2 = active and propage feature on all inactive childrens");
	ReadSave_String_Const(IO,"IK NODE Nmuber");
	ReadSave_U32(IO,&OBJ->ulNumberOfPatchs);
	Signify_Ptr(IO,(void**)&OBJ->pObjPatchs,sizeof(IK_ObjectPatch) * OBJ->ulNumberOfPatchs);
	for (int i = 0; i < OBJ->ulNumberOfPatchs ; i ++)
	{
		ReadSave_String_Const(IO,"IK NODE **************************************************");
		ReadSave_Name(IO,&OBJ->pObjPatchs[i].ObjectID,"Object Name");
		ReadSave_String_Const(IO,"Flags");
		ReadSave_U32(IO,&OBJ->pObjPatchs[i].ulFlags);
		if (Version >= 2)
		{
			ReadSave_String_Const(IO,"HeritageStart (if flags == 2)");
			ReadSave_U32(IO,&OBJ->pObjPatchs[i].HeritageStart);
		}
		ReadSave_String_Const(IO,"Springht strenght");
		ReadSave_FLOAT(IO,&OBJ->pObjPatchs[i].fSpringStrength);
		if (Version >= 3)
		{
			ReadSave_String_Const(IO,"Weight");
			ReadSave_Vector(IO,&OBJ->pObjPatchs[i].vWeight);
		} else
		{
			ReadSave_String_Const(IO,"Weight");
			ReadSave_FLOAT(IO,&OBJ->pObjPatchs[i].vWeight.z);
			OBJ->pObjPatchs[i].vWeight.x = OBJ->pObjPatchs[i].vWeight.y = 0.0f;
		}
		ReadSave_String_Const(IO,"Velocity absorbtion");
		ReadSave_FLOAT(IO,&OBJ->pObjPatchs[i].VelocityAbsorbtion);
		ReadSave_String_Const(IO,"Max torsion Angle (0.0 = rigide ; 1.0 = 90° ; >2.0 = disactivate)");
		ReadSave_FLOAT(IO,&OBJ->pObjPatchs[i].MaxAngle);
	}


	if (Version >= 1)
	{
		ReadSave_String_Const(IO,"IK Node END, Colliders begin *********************************************************************************");
		ReadSave_String_Const(IO,"Collider numbers");
		ReadSave_U32(IO,&OBJ->ulNumberOfCollider);
		Signify_Ptr(IO,(void**)&OBJ->pColliders,sizeof(IK_Collider) * OBJ->ulNumberOfCollider);
		for (int i = 0; i < OBJ->ulNumberOfCollider ; i ++)
		{
			ReadSave_String_Const(IO,"IK Colliders **************************************************");
			ReadSave_Name(IO,&OBJ->pColliders[i].ObjectID,"Object Name");
			ReadSave_String_Const(IO,"Ellipse Radius (x,y,z)");
			ReadSave_Vector(IO,&OBJ->pColliders[i].Radius);
			ReadSave_String_Const(IO,"Ellipse Center (x,y,z)");
			ReadSave_Vector(IO,&OBJ->pColliders[i].Center);
		}
	}

	CHECK_END();
}
DECLARE_IO_C(SmallScene_IK);
/****************************************************************************************************************/
/****************************************************************************************************************/
/* SmallScene IO																								*/
/****************************************************************************************************************/
/****************************************************************************************************************/
u32 SmallScene_LoadSave(IO_STRUCT *IO,SmallScene *OBJ)
{
	char Name[2048];

	CHECK_VERSION(5);

	if (IO->Dico == NULL) return IO_FAIL(IO);

	ReadSave_String_Const(IO,"Msh number");
	ReadSave_U32(IO,&OBJ->ulNumberOfMeshes);
	Signify_Ptr(IO,(void**)&OBJ->MeshesIDs,sizeof(UnicID) * OBJ->ulNumberOfMeshes);
	Signify_Ptr(IO,(void**)&OBJ->MeshesPtrs,sizeof(Mesh*) * OBJ->ulNumberOfMeshes);
	ReadSave_Name_Index(IO,OBJ->MeshesIDs,"Msh",OBJ->ulNumberOfMeshes);

	ReadSave_String_Const(IO,"Mat number");
	ReadSave_U32(IO,&OBJ->ulNumberOfMaterials);
	Signify_Ptr(IO,(void**)&OBJ->MaterialsIDs,sizeof(UnicID) * OBJ->ulNumberOfMaterials);
	Signify_Ptr(IO,(void**)&OBJ->MaterialsPtrs,sizeof(_3D_Material*) * OBJ->ulNumberOfMaterials);
	Signify_Ptr(IO,(void**)&OBJ->MaterialsRedirs,sizeof(u32*) * OBJ->ulNumberOfMaterials);
	ReadSave_Name_Index(IO,OBJ->MaterialsIDs,"Mat",OBJ->ulNumberOfMaterials);

	ReadSave_String_Const(IO,"Mmt number");
	ReadSave_U32(IO,&OBJ->ulNumberOfMultiMats);
	Signify_Ptr(IO,(void**)&OBJ->MultiMaterialsIDs,sizeof(UnicID) * OBJ->ulNumberOfMultiMats);
	Signify_Ptr(IO,(void**)&OBJ->MultiMaterialsPtrs,sizeof(_3D_MultiMaterial*) * OBJ->ulNumberOfMultiMats);
	ReadSave_Name_Index(IO,OBJ->MultiMaterialsIDs,"Mmt",OBJ->ulNumberOfMultiMats);

	ReadSave_String_Const(IO,"Obj number");
	ReadSave_U32(IO,&OBJ->ulNumberOfObjects);
	Signify_Ptr(IO,(void**)&OBJ->ObjectsIDs,sizeof(UnicID) * OBJ->ulNumberOfObjects);
	Signify_Ptr(IO,(void**)&OBJ->ObjectsPtrs,sizeof(_3D_Object*) * OBJ->ulNumberOfObjects);
	ReadSave_Name_Index(IO,OBJ->ObjectsIDs,"Obj",OBJ->ulNumberOfObjects);

	if (Version >= 5)
	{
		ReadSave_String_Const(IO,"Lights number");
		ReadSave_U32(IO,&OBJ->ulNumberOfLights);
		Signify_Ptr(IO,(void**)&OBJ->LightsIDs,sizeof(UnicID) * OBJ->ulNumberOfLights);
		Signify_Ptr(IO,(void**)&OBJ->LightsPtrs,sizeof(_3D_Light*) * OBJ->ulNumberOfLights);
		ReadSave_Name_Index(IO,OBJ->LightsIDs,"Lights",OBJ->ulNumberOfLights);
	}


	if (Version >= 1)
	{
		ReadSave_String_Const(IO,"Camera MATRIX");
		ReadSave_Matrix(IO,&OBJ->CameraPosition);

		u32 Dummy;
		if (Version == 2)
		{
			ReadSave_String_Const(IO,"Tracks number");
			ReadSave_U32(IO,&Dummy);
		} 
		if (Version >= 4)
		{
			ReadSave_String_Const(IO,"Compute Inverse Skinning");
			ReadSave_U32(IO,&OBJ->MustComputeInverseSkinning);
		} else
			OBJ->MustComputeInverseSkinning = 0;
	} else
		OBJ->CameraPosition.Identity();

	CHECK_END();
}

DECLARE_IO_C(SmallScene);
/****************************************************************************************************************/
/****************************************************************************************************************/
/* Particules IO																								*/
/****************************************************************************************************************/
/****************************************************************************************************************/

u32 PGENERATOR_OBJ_LoadSave(IO_STRUCT *IO, PGENERATOR_OBJ *OBJ)
{
	CHECK_VERSION(5);
	
	ReadSave_String_Const(IO,"Mask Options - 0: Default; 1: Force No Collides; 2:Kill when speed=0; 4: Kill when stop; 8: Gen on surface; 16: Random gen pos");
	ReadSave_U32(IO, (u32 *)&OBJ->options);

	ReadSave_String_Const(IO,"Particle number");
	ReadSave_U32(IO, (u32 *)&OBJ->maxParticules);
	ReadSave_String_Const(IO,"Particle Repeat");
	ReadSave_U32(IO, (u32 *)&OBJ->particuleRepeat);
	ReadSave_String_Const(IO,"Particle life");
	ReadSave_U32(IO, (u32 *)&OBJ->particuleLife);
	ReadSave_String_Const(IO,"Particle life Random");
	ReadSave_FLOAT(IO, &OBJ->particuleLifeRand);
	ReadSave_String_Const(IO,"Particle Gen Speed");
	ReadSave_FLOAT(IO, &OBJ->genSpeed);
	ReadSave_String_Const(IO,"Particle Gen Speed Random");
	ReadSave_FLOAT(IO, &OBJ->genSpeedRand);
	ReadSave_String_Const(IO,"Particle Gen Angle");
	ReadSave_FLOAT(IO, &OBJ->genAngleAllowed);
	ReadSave_String_Const(IO,"Particle Gen Power");
	ReadSave_FLOAT(IO, &OBJ->genPower);
	ReadSave_String_Const(IO,"Particle Gen Power Random");
	ReadSave_FLOAT(IO, &OBJ->genPowerRand);
	ReadSave_String_Const(IO,"Particle Gen Number");
	ReadSave_U32(IO, (u32 *)&OBJ->genNumber);
	ReadSave_String_Const(IO,"Particle Width");
	ReadSave_FLOAT(IO, &OBJ->genWidth);
	ReadSave_String_Const(IO,"Particle Height");
	ReadSave_FLOAT(IO, &OBJ->genHeight);
	ReadSave_String_Const(IO,"Particle Size Rand");
	ReadSave_FLOAT(IO, &OBJ->genSizeRand);
	
	ReadSave_String_Const(IO,"Texture Media");
	ReadSave_String(IO, OBJ->MediaName);
	ReadSave_String_Const(IO,"Texture Blend");
	ReadSave_U16(IO, &OBJ->BlendMode);
	ReadSave_String_Const(IO,"Texture Alpha Threshold");
	ReadSave_U32(IO, (u32 *)&OBJ->AlphaThreshold);
	ReadSave_String_Const(IO,"Texture Grid");
	ReadSave_U32(IO, (u32 *)&OBJ->TextureGrid.cx);
	ReadSave_U32(IO, (u32 *)&OBJ->TextureGrid.cy);
	ReadSave_String_Const(IO,"Texture Anim Speed");
	ReadSave_U32(IO, (u32 *)&OBJ->forces.AnimSpeed);
	ReadSave_String_Const(IO,"Texture Anim Repeat");
	ReadSave_U32(IO, (u32 *)&OBJ->forces.AnimRepeat);
	ReadSave_String_Const(IO,"Texture Anim Init - -1 for random");
	ReadSave_U32(IO, (u32 *)&OBJ->forces.AnimInit);

	ReadSave_String_Const(IO,"Gravity");
	ReadSave_Vector(IO, &OBJ->forces.Gravity);

	ReadSave_String_Const(IO,"Frictions");
	ReadSave_FLOAT(IO, &OBJ->forces.Frictions);

	ReadSave_String_Const(IO,"Wind Direction");
	ReadSave_Vector(IO, &OBJ->forces.WindDirection);
	ReadSave_String_Const(IO,"Wind Force");
	ReadSave_FLOAT(IO, &OBJ->forces.WindForce);

	ReadSave_String_Const(IO,"Rotation Speed");
	ReadSave_FLOAT(IO, &OBJ->forces.RotationSpeed);
	ReadSave_String_Const(IO,"Rotation Random");
	ReadSave_FLOAT(IO, &OBJ->forces.RotationRand);

	if (Version >= 5)
	{
		ReadSave_String_Const(IO,"Rotation Init - Random between A and B");
		ReadSave_FLOAT(IO, &OBJ->forces.RotationInit);
		ReadSave_FLOAT(IO, &OBJ->forces.RotationInit2);
	} else
	{
		OBJ->forces.RotationInit = 0;
		OBJ->forces.RotationInit2 = 0;
	}

	ReadSave_String_Const(IO,"Grow For");
	ReadSave_U32(IO, (u32 *)&OBJ->forces.GrowFor);
	ReadSave_FLOAT(IO, &OBJ->forces.GrowForInit);
	ReadSave_FLOAT(IO, &OBJ->forces.GrowForEnd);
	ReadSave_String_Const(IO,"Grow For Rand");
	ReadSave_FLOAT(IO, &OBJ->forces.GrowForRand);
	ReadSave_String_Const(IO,"Fade For");
	ReadSave_U32(IO, (u32 *)&OBJ->forces.FadeFor);
	ReadSave_FLOAT(IO, &OBJ->forces.FadeForInit);
	ReadSave_FLOAT(IO, &OBJ->forces.FadeForEnd);
	ReadSave_String_Const(IO,"Fade For Rand");
	ReadSave_FLOAT(IO, &OBJ->forces.FadeForRand);

	ReadSave_String_Const(IO,"Grow For Color");
	ReadSave_U32(IO, (u32 *)&OBJ->forces.GrowForColor);
	ReadSave_Color(IO, (u32 *)&OBJ->forces.GrowForColorInit);
	ReadSave_Color(IO, (u32 *)&OBJ->forces.GrowForColorEnd);

	ReadSave_String_Const(IO,"Fade For Color");
	ReadSave_U32(IO, (u32 *)&OBJ->forces.FadeForColor);
	ReadSave_Color(IO, (u32 *)&OBJ->forces.FadeForColorInit);
	ReadSave_Color(IO, (u32 *)&OBJ->forces.FadeForColorEnd);

	ReadSave_String_Const(IO,"Collision Friction");
	ReadSave_FLOAT(IO, &OBJ->forces.collisionFriction);
	ReadSave_String_Const(IO,"Collision Rand Anglet");
	ReadSave_FLOAT(IO, &OBJ->forces.collisionRandAngle);

	ReadSave_String_Const(IO,"Particule Son Mode - 0: No Son; 1: On die; 2: On Collide");
	ReadSave_U32(IO, (u32 *)&OBJ->sonMode);
	ReadSave_String_Const(IO,"Particule Son");
	ReadSave_String(IO, OBJ->son);

	CHECK_END();
}

DECLARE_IO_C(PGENERATOR_OBJ);

/****************************************************************************************************************/
/****************************************************************************************************************/
/* Fur IO																								*/
/****************************************************************************************************************/
/****************************************************************************************************************/

u32 FUR_OBJ_LoadSave(IO_STRUCT *IO, FUR_OBJ *OBJ)
{
	CHECK_VERSION(2);
	
	ReadSave_String_Const(IO,"Fur Mode 1-Use Orientation, 2-Orientation on U, 4-Look At");
	ReadSave_U32(IO, (u32 *)&OBJ->Mode);
	ReadSave_String_Const(IO,"Fur number");
	ReadSave_U32(IO, (u32 *)&OBJ->nbFurElmt);

	ReadSave_String_Const(IO,"Sprite Media");
	ReadSave_String(IO, OBJ->SpriteTextureMatName);
	ReadSave_String_Const(IO,"Sprite Width");
	ReadSave_FLOAT(IO, &OBJ->SpriteWidth);
	ReadSave_String_Const(IO,"Sprite Width Random - if WR == HR use same scale");
	ReadSave_FLOAT(IO, &OBJ->SpriteWidthRand);
	ReadSave_String_Const(IO,"Sprite Height");
	ReadSave_FLOAT(IO, &OBJ->SpriteHeight);
	ReadSave_String_Const(IO,"Sprite Height Random - if WR == HR use same scale");
	ReadSave_FLOAT(IO, &OBJ->SpriteHeightRand);
	ReadSave_String_Const(IO,"Position");
	ReadSave_FLOAT(IO, &OBJ->SpritePosition);
	ReadSave_String_Const(IO,"Fur Levels");
	ReadSave_U32(IO, (u32 *)&OBJ->SpriteLevels);
	
	ReadSave_String_Const(IO,"Mass texture");
	ReadSave_String(IO, OBJ->MassTextureName);
	if (Version >= 2)
	{
		ReadSave_String_Const(IO,"Color texture");
		ReadSave_String(IO, OBJ->ColorTextureName);
	} else
	{
		*OBJ->ColorTextureName = 0;
	}

	ReadSave_String_Const(IO,"Orientation Rigidity Inv");
	ReadSave_FLOAT(IO, &OBJ->OrientationStrengh);
	ReadSave_String_Const(IO,"Orientation Meca Delay Inv");
	ReadSave_FLOAT(IO, &OBJ->OrientationMeca.elasticity);
	ReadSave_String_Const(IO,"Orientation Meca Friction Inv");
	ReadSave_FLOAT(IO, &OBJ->OrientationMeca.friction);
	ReadSave_String_Const(IO,"NB Orientation");
	ReadSave_U32(IO,(u32 *)&OBJ->nbOrientation);
	Signify_Ptr(IO,(void**)&OBJ->OrientationList,sizeof(Vector) * OBJ->nbOrientation);
	for (int i = 0; i < OBJ->nbOrientation ; i ++)
	{
		ReadSave_Vector(IO,&OBJ->OrientationList[i]);
	}
	CHECK_END();
}

DECLARE_IO_C(FUR_OBJ);