#define STRICT

// Includes standard Windows
#include <windows.h>
#include <windowsx.h>
#include <time.h>
#include <stdlib.h>
#include <malloc.h>
#include <memory.h>
#include <stdio.h>

// Includes D3D
#define  D3D_OVERLOADS
#include <ddraw.h>
#include <d3d.h>

// Includes utilitaires D3D
#include "d3dmath.h"
#include "d3dutil.h"
#include "D3DEnum.h"
#include <d3dx.h>

// Ids Resources
#include "resource.h"

// Constantes
#include "const.h"

// Types
#include "types.h"

// Variables globales projet
#include "vars.h"

// Prototypes fonctions autres modules
#include "proto.h"

// Macros
#include "macros.h"

//************************************* C O M M U N S ***********************
void vDeleteD3DObjects(void)
{
	// RAZ Objets D3D
	for (int iObject = 0 ; iObject < XDC_NUMOBJECTS ; iObject++)
	{
		if (!Objects[iObject].bEnabled) continue;
		
//		  Objects[iObject].pShape -> Release();
		Objects[iObject].bEnabled = FALSE;
		Objects[iObject].bHidden = FALSE;
	}
	iObjtFirstAvailable = 0;
	iObjtLastUsed = -1;
}

int iMakeD3DObj(void)
{
	int iCnt;

	// Rechercher un slot libre
	for (iCnt = iObjtFirstAvailable ; (iCnt <= iObjtLastUsed) && (Objects [iCnt].bEnabled == TRUE) ; iCnt++);

	// Si pas trouvé alors fail
	if (iCnt >= XDC_NUMOBJECTS)
	{
		vTrace("*** E0023 : Plus de slots objets libres");
		return -1;
	}

	// Créer l'objet
	Objects[iCnt].vOrigin = D3DVECTOR(0.f, 0.f, 0.f);
	Objects[iCnt].bEnabled = TRUE;
	Objects[iCnt].bHidden = FALSE;
	Objects[iCnt].bSelected = FALSE;

	while (Objects[iObjtFirstAvailable].bEnabled == TRUE) iObjtFirstAvailable++;
	if (iObjtLastUsed < iCnt) iObjtLastUsed = iCnt;
	
	return iCnt;
}

int iFindD3DObject(D3DVECTOR p, int iPrevious)
{
	int iCnt;
	float fTolerance = (float) fabs(fXmax - fXmin) / XDC_ZONE;
	
	// Rechercher 
	for (iCnt = max(iPrevious + 1, 0) ;
		    (iCnt <= iObjtLastUsed)
		 && (!(   (Objects[iCnt].bEnabled == TRUE)
			   && (Objects[iCnt].bHidden == FALSE)
			   && (fabs(Objects[iCnt].vOrigin.x - p.x) < fTolerance)
			   && (fabs(Objects[iCnt].vOrigin.y - p.y) < fTolerance)
			   && (fabs(Objects[iCnt].vOrigin.z - p.z) < fTolerance)
			  ))
		 ;
		 iCnt++) ;

	// Si trouvé alors renvoyer son indice
	if (iCnt <= iObjtLastUsed)
		return(iCnt);

	// Sinon renvoyer -1
	return -1;
}

BOOL bMoveD3DObj(int iObject, D3DVECTOR vPos)
{
/*
	if (Objects[iObject].bEnabled == FALSE) return FALSE;

	LPDIRECT3DVERTEXBUFFER7 vBuf = Objects[iObject].pShape -> GetVB();
	D3DVERTEXBUFFERDESC vbDesc;

	vbDesc.dwSize = sizeof(vbDesc);
	vBuf -> GetVertexBufferDesc(&vbDesc);

	if (vbDesc.dwFVF != D3DFVF_VERTEX) return FALSE;

	D3DVERTEX *vbAddr;
	unsigned long iSize;

	vBuf -> Lock(DDLOCK_SURFACEMEMORYPTR, (void **) &vbAddr, &iSize);

	for (unsigned iVertex = 0 ; iVertex < vbDesc.dwNumVertices ; iVertex++)
	{
		vbAddr[iVertex].x += vPos.x;
		vbAddr[iVertex].y += vPos.y;
		vbAddr[iVertex].z += vPos.z;
	}

	vBuf -> Unlock();

	vBuf -> Release();

	Objects[iObject].vOrigin += vPos;
*/
	return TRUE;
}