#ifndef _TRACK_H_
#define _TRACK_H_

#include "DEFINES.H"

#include <Windows.h>
#include <stdio.h>
#include <stdlib.h>
#include "CC_alloc.h"
#include "fileIO.h"
#include <memory.h>
#include <MATH.H>
#include <string.h>


#ifndef __DEFINE_NUMS__
#define __DEFINE_NUMS__

#define f32 float
#define u32 unsigned int
#define s32 int
#define u16 unsigned short
#define s16 signed short
#define u8 unsigned char
#define s8 char

#endif

#include "TOOLS.h"


inline void *ZeroAlloc(u32 Size)
{
	void *Ret;
	Ret = CC_malloc(Size);
	memset(Ret,0,Size);
	return Ret;
}

inline void *ZeroRealloc(void* ptr, u32 Size)
{
	void *Ret;
	Ret = CC_realloc(ptr, Size);
	memset(Ret,0,Size);
	return Ret;
}


/* Draw functions */
typedef struct DrwTEXT_UI_ {
	s32 X,Y;
	s32 XEnd,YEnd;
	s32 CursorPosX,CursorPosY;
	u32 CursorPos,CursorPosUP,CursorPosDown;
	u32 CurrentCursorPos;
	u32 SelStart,SelEnd;
	u32 ColorFront,ColorBack;
	s32 MouseX,MouseY,MouseToCursor;
	u32	Birth;
	u32	Age;
	u32 InsertMode;
	u32 DontDraw;
	u32 HCenter;
	u32 ModePassword;
	SIZE		*FONT_CharBounds;
	SIZE		*FONT_CharPos;
	MAP			*FONT_Image;
	u32			FONT_AlphaMode;
	TEXTMETRIC	*FONT_Metrix;
} DrwTEXT_UI;

void DRawTEXT_UserInterface(unsigned char *pTEXT,u32 *pBase,s32 Pitch , u32 Height , DrwTEXT_UI *DUI);
void DRawTEXT_Soft_B(unsigned char *pTEXT,u32 *pBase,u32 X, u32 Y, s32 Pitch , u32 Height , u32 Color);
void DRawTEXT_Soft_B(unsigned char *pTEXT,u32 *pBase,u32 X, u32 Y, s32 Pitch , u32 Height , u32 Color);
void DRawTEXT_Soft_B2x(unsigned char  *pTEXT,u32 *pBase,u32 X, u32 Y, s32 Pitch , u32 Height , u32 Color);
void DRawTEXT_Soft_B_Centered(u8 *pTEXT,u32 *pBase,s32 Pitch , u32 Height , u32 Color);



#define ARGB2ABGR(color) ((color & 0xFF000000) | ((color & 0xFF0000)>>16) | (color & 0xFF00) | ((color & 0xFF)<<16))

class Color4 
{
public:
	union
	{
		float	m_tab[4];
		struct
		{
			float m_a;
			float m_r;
			float m_g;
			float m_b;
		};
	};
	
	Color4()
	{
		m_a = 1.f;
		m_r = 1.f;
		m_g = 1.f;
		m_b = 1.f;
	}
	Color4(u32 _color) {
		fromU32(_color);
	}

	Color4(float _a, float _r, float _g, float _b) { m_a = _a; m_r = _r; m_g = _g; m_b = _b; }
	void fromU32(u32 _color)
	{
		m_a = (float)((_color >> 24) & 0xff) / 255.f; 
		m_r = (float)((_color >> 16) & 0xff) / 255.f; 
		m_g = (float)((_color >>  8) & 0xff) / 255.f; 
		m_b = (float)((_color      ) & 0xff) / 255.f; 
	}
	u32 toU32Color() {
		u32 finalColor = 0;
		f32 tmpColor;
		tmpColor = m_a * 255.f;
		if (tmpColor > 255.f) tmpColor = 255.f;
		if (tmpColor < 0.f) tmpColor = 0.f;
		finalColor = finalColor << 8 | (u32)tmpColor;
		tmpColor = m_r * 255.f;
		if (tmpColor > 255.f) tmpColor = 255.f;
		if (tmpColor < 0.f) tmpColor = 0.f;
		finalColor = finalColor << 8 | (u32)tmpColor;
		tmpColor = m_g * 255.f;
		if (tmpColor > 255.f) tmpColor = 255.f;
		if (tmpColor < 0.f) tmpColor = 0.f;
		finalColor = finalColor << 8 | (u32)tmpColor;
		tmpColor = m_b * 255.f;
		if (tmpColor > 255.f) tmpColor = 255.f;
		if (tmpColor < 0.f) tmpColor = 0.f;
		finalColor = finalColor << 8 | (u32)tmpColor;
		return finalColor;
	}

	float & operator[] (u32 _index) { return m_tab[_index]; }
	Color4 operator+ (Color4 _color) { return Color4(m_a + _color.m_a, m_r + _color.m_r,m_g + _color.m_g,m_b + _color.m_b); }
	Color4 operator+= (Color4 _color) {
		m_a+=_color.m_a;
		m_r+=_color.m_r;
		m_g+=_color.m_g;
		m_b+=_color.m_b;
		return *this;
	}
	Color4 operator- (Color4 _color) { return Color4(m_a - _color.m_a, m_r - _color.m_r,m_g - _color.m_g,m_b - _color.m_b); }
	Color4 operator-= (Color4 _color) {
		m_a-=_color.m_a;
		m_r-=_color.m_r;
		m_g-=_color.m_g;
		m_b-=_color.m_b;
		return *this;
	}
	Color4 operator* (f32 val) { return Color4(m_a*val,m_r*val,m_g*val,m_b*val); }

};

typedef struct RS_
{
	u8 LIGHTED:1;
	u8 WIRED:1;
	u8 BACKFACE:1;
	u8 BACKFACE_INVERT:1;
	u8 NOZWRITE:1;
	u8 NOZTEST:1;
	u8 TEXTURED:1;
	u8 HIDECOLOR:1;
	u8 HIDEALPHA:1;
	u8 SECONDPASS:1;
	u8 INVERTALPHA:1;
	u8 PICKABLE:1;
	u8 SKIPLAYER:1;
	u8 TEXTUREREPEAT_U:1;
	u8 TEXTUREREPEAT_V:1;
	u8 PICKABLE_NO_TRANSPARENCY:1;
	u8 ZEQUAL:1;
	u8 ZPASS:1;
	u8 USEVERTEXCOLORS:1;
	u8 TEXTUREBILINEAR:1;
	/*
		UV MATRIX	| 0 1 |
					| 2 3 |
		translation [ 4 5 ]
	*/
	float UVMATRIX[6]; 
#define BLENDING_MODES "BLENDING MODES: 0=COPY;1=ALPHA;2=ADD;3=ALPHA PREMULT;4=PREVIOUS ALPHA;5=Multiply;6=Multiply Invert;7=Multiply x 2"
#define MAPPING_MODES "MAPPING MODES: 0=OBJECT;1=CHROME;2=PLANAR Z;3=PLANAR SCRENN;4=OBJECT UV2"
	u8	BlendingMode;
	u8	MappingMode;
	u8	AlphaThreshold;
	float NormalExtraction;

/// animation on textures
	u16		AnimNbX;
	u16		AnimNbY;
	float	AnimFPS;
	DWORD	AnimTime;
} RS;

_inline void GLOB_SetDefaultRS(RS *RenderMode) 
{
	RenderMode->WIRED = 0;
	RenderMode->LIGHTED = 0;
	RenderMode->BACKFACE = 1;
	RenderMode->BACKFACE_INVERT = 0;
	RenderMode->NOZWRITE = 0;
	RenderMode->ZEQUAL = 0;
	RenderMode->ZPASS = 0;
	RenderMode->NOZTEST = 0;
	RenderMode->TEXTURED = 1;
	RenderMode->HIDECOLOR = 0;
	RenderMode->HIDEALPHA = 0;
	RenderMode->SECONDPASS = 0;
	RenderMode->INVERTALPHA = 0;
	RenderMode->PICKABLE = 1;
	RenderMode->PICKABLE_NO_TRANSPARENCY = 0;
	RenderMode->SKIPLAYER = 0;
	RenderMode->TEXTUREREPEAT_U = 1;
	RenderMode->TEXTUREREPEAT_V = 1;
	RenderMode->UVMATRIX[0] = RenderMode->UVMATRIX[3] = 1; 
	RenderMode->UVMATRIX[1] = RenderMode->UVMATRIX[2] =
	RenderMode->UVMATRIX[4] = RenderMode->UVMATRIX[5] = 0; 
	RenderMode->BlendingMode = 0 /* Copy */;
	RenderMode->MappingMode = 0 /* Copy */;
	RenderMode->AlphaThreshold = 0;
	RenderMode->NormalExtraction = 0.0f;
	RenderMode->USEVERTEXCOLORS = 0;
	RenderMode->TEXTUREBILINEAR = 1;

	RenderMode->AnimNbX = 1;
	RenderMode->AnimNbY = 1;
	RenderMode->AnimFPS = 0.0f;
	RenderMode->AnimTime= 0;
};

#define MAX_LIGHT 20
#define MAX_BROCH 20

typedef struct Light_
{
	struct _3D_Light_	*LightDesc;
	Vector		Position;
	Vector		Direction;
} Light;


typedef struct OPENGL_TEXTURE_
{
	MAP		*pExtRef;
	u32		OGLRef; // -1 mean notexture
	u32		ColorMode; // 0 = RGBA ; 1 = BW
	u32		ClampMode; // 1 = clamp U , 2 = clamp V , 3 clamp UV
	u32		CacheCounter;
	u32		LayerIndex; // -1 mean not a layered texture
	u32		LastHash;
	u32		IsMipMapped;
} OPENGL_TEXTURE;
#define MaxOglTexture 2048
//#define MaxOglTexture 4096

#define NUMBER_OF_WORKING_REF 12
class DrawInterface
{
public:
	u32		FORCE_RENDER_FLAG;
	u32		PickingEnable;
	Vector	MousePicking;
	Vector	MousePickingXYZ;
	Vector	MousePickingUVW;
	u32		MousePickingTri;
	float	MousePickingCurrentZ;
	MAP		*pPickedTexture;
	class WORLD	*MotherClass;
	Light	AllLight[MAX_LIGHT];
	u32		AllLightNumber;//*/
	void	*pComputingBuffer;
	u32		ComputingBufferSize;
	float	ComputeMaskAlpha;
	u32		OptimiseQuadRender;

	u32 FB_SX,FB_SY;
	u32	CurrentColor;

	u32		QuadRotation_ON;
	MATRIX	QuadRotationMatrix;
	float	QuadRotation_Focale;
	float	QuadUVMatrix[4]; // X,Y,W,H
	Vector	QuadDisplace;
	u32		QuadHideColor;

	float CurrentViewport[4];
	float SavedCurrentViewport[4];
	float ZBIas;
	float ZQuad;


	s32		RenderTargetBaseX;
	s32		RenderTargetBaseY;
	u32		RenderTargetState;
	u32		OGLTextureSizeX;
	u32		OGLTextureSizeY;

	u32		RectifyTextOrigin;


	RECT	ActivRect;
	RECT	ScissorRect;


	HWND OpenglDisplayer;		// Local Window

	OPENGL_TEXTURE	AllRef[MaxOglTexture];
	RS				CurrentRS;
	RS				LastRS;
	u32				ulNumberOfTexture;
	u32				ulCurrentTexture;
	HDC				hDC;
	HGLRC			hRC;
	HWND			CurrenthWnd;
	RECT			CurrentRect;
	RECT			hDCRect;
	float			fFocUsed;
#define NUMBER_OF_OGL_WORKING_REF NUMBER_OF_WORKING_REF
	u32				OGLWorkingRef[NUMBER_OF_OGL_WORKING_REF];
	u32				IsVisible;


	void AddALight(struct _3D_Light_ *pLight,Vector *Position,Vector *Direction) 
	{
		if (AllLightNumber < MAX_LIGHT)
		{
			AllLight[AllLightNumber].LightDesc = pLight;
			AllLight[AllLightNumber].Position = *Position;
			AllLight[AllLightNumber].Direction = *Direction;
			AllLightNumber++;
		};
	};
	void ClearLight() 
	{
		AllLightNumber = 0;
	};

	virtual void Begin(RECT *HdcRect) = 0;
	virtual void End() = 0;
	virtual void Flush() = 0;

	virtual void Perspective(float FocaleLenght) = 0;
	virtual void Holographic(Vector *pUserpos,float WindowWith) = 0;
	virtual void Ortho() = 0;
	virtual void Flip(s32 ShowMe) = 0;

	virtual void Clear(u32 Color) = 0;
	virtual void ClearZ() = 0;

	virtual void Matrix(MATRIX *MatrixToSet) = 0;
	virtual void RenderMesh(Mesh *pMyMesh,u32 Num, u32 Base) = 0;
			void RenderMesh(Mesh *pMyMesh) {RenderMesh(pMyMesh,pMyMesh->NumberOfFaces,0);};
	virtual void ReverseRenderMesh(Mesh *pMyMesh,u32 TextureSource,u32 Num, u32 Base) = 0;
			void ReverseRenderMesh(Mesh *pMyMesh,u32 TextureSource) {ReverseRenderMesh(pMyMesh,TextureSource,pMyMesh->NumberOfFaces,0);};

	virtual void SetRS(RS *RenderMode,u32 TextureIndex) = 0;
	virtual void DrawQuad(u32 Color,float X, float Y,float Xsize, float Ysize,float TX,float TY,float TW,float TH) = 0;
	void DrawCircle(u32 TextureIndex,Vector *Center, float InnerRadius, float OuterRadius, float ClockDegreeStart,float ClockDegreeEnd,RS *RenderState);
	void DrawPatch32(u32 TextureIndex,Vector *Point, Color4*Colors, u32 drawHalf,u32 NumberOfCurves,u32 HDIV, u32 VDIV,RS *RenderState);


	virtual void SetCurrentColor(u32 Color) = 0;
	virtual u32 GetCurrentColor() {return 0xffffffff;};

	virtual void ReadFrameBuffer(s32 X,s32 Y,s32 SX,s32 SY, MAP *dest) = 0;

	/* Texture management */
	virtual u32  CreateTexture(MAP *pExternalReferenceRGBA,u32 Colormode, bool forceCreation = false) {return (u32)-1;};
	virtual u32  CreateLayerTexture(MAP *pExternalReferenceRGBA,u32 LayerIndex) = 0;
	virtual void DestroyLayerTexture(u32 TextureIndex) = 0;

	virtual void SetTextureColorMode(u32 Index,u32 ColorMode) = 0;
	virtual void UpdateTexture_BM_2_HW(u32 TextureIndex, bool isDynmaic = true) = 0;
	virtual void UpdateTexture_HW_2_BM(u32 TextureIndex,u32 UpdateSoftBuffer) = 0;
	virtual void UpdateTexture_HW_2_BM(u32 TextureIndex,u32 UpdateSoftBuffer,s32 SourceX,s32 SourceY) = 0;

	virtual void DestroyTexture(u32 TextureIndex) = 0;
	void SetBackGround(u32 TextureIndex,u32 Blend = 0);
	void DrawQuad(u32 TextureIndex,s32 XMin,s32 XMax,s32 YMin,s32 YMax,RS *RenderMode = NULL);
	void DrawQuadDistord(u32 TextureIndex,s32 XMin,s32 XMax,s32 YMin,s32 YMax,RS *RenderMode = NULL);
	void DrawCenteredQuad(u32 Color,float Xsize, float Ysize, float FX,float FY);

	void Process2DProjection();
	void Process2DRotation(u8 begin, s32 bnd0X = 0, s32 bnd1X = 0, s32 bnd0Y = 0, s32 bnd1Y = 0);

	void DrawMultipleQuads(u32 TextureIndex,u32 Number,s32 *Bounds,float *BoundsUV,RS *RenderState = NULL);
	void Draw2DLine(u32 TextureIndex, Vector *A, Vector *B, int Lenght, RS *RenderState = NULL);
	virtual void DrawLine(u32 Color,Vector *A,Vector *B, int Lenght = 0) = 0;

	void SetQuadHideColorAlpha(int C,int A);
	void SetQuadRot(float Focale , Vector *pAxisAngle , Vector *pCenter);
	void SetQuadDisplace(Vector *pDisplace);
	void SetQuadUVSource(float BasU,float BasV,float WU,float WV);
	void SetQuadDefault();

	virtual void Setexture(u32 TextureIndex,float *UVMatrix = NULL) = 0;
	virtual void SetFog(u32 OnOff,float Near , float far , u32 Color) = 0;

	virtual void BeginTextureTarget(u32 TextureIndex,u32 SaveFrontBuffer = 0) = 0;
	virtual void EndTextureTarget(u32 TextureIndex,u32 bUpdateSoftBuffer) = 0;

	virtual void ChangeMode(HWND Mother, bool UseGDI) = 0;
	virtual void SetResolution(u32 X,u32 SY) = 0;
	virtual void SetViewport(s32 X,s32 Y,s32 SX,s32 SY) = 0;
	void GetViewport(s32 *X,s32 *Y,s32 *SX,s32 *SY) 
	{
		*X = s32(CurrentViewport[0]) ;
		*Y = s32(CurrentViewport[1]) ;
		*SX = s32(CurrentViewport[2]) ;
		*SY = s32(CurrentViewport[3]) ;
	}

	virtual void SetClipping(s32 X,s32 Y,s32 SX,s32 SY) = 0;
	virtual void AfterEffect(u32 ulType,u32 Color,float Factor1,float Factor2,float Factor3 = 0.0f,float Factor4 = 0.0f,float Factor5 = 0.0f) = 0;
	virtual void LayerOperation(u32 ulType,u32 SlotIndex,u32 Color,float Factor1,float Factor2) = 0;

	/* Picking */
	void Mul4x4Matrix(float *M1,float *M2,float *MR);
	void PickMesh(Mesh *pMyMesh,u32 Num, u32 Base);
	void PickQuad(u32 Color,float X, float Y,float Xsize, float Ysize,float TX,float TY,float TW,float TH);
	void PickQuadGone(u32 Color,Vector *XYZ, Vector *UV);

	/* Text */
	u32	 FontTextureIndex;
	MAP  FontMap;

	void init_font(void);
	void DrawText(unsigned char *Txt,float  X, float  Y, float FX, float FY , u32 ColorRGBA , u32 DrawModeShadow = 1);
	void DrawTextCentered(unsigned char *pTEXT,u32 Color);
	void RenderText(unsigned char *Txt,float X, float Y, float FX, float FY , u32 ColorRGBA, MAP *fontMap, int TextureIdx, SIZE *CharPos, SIZE *CharBounds, u32 optionMask, int blendingMode = -1);
	void GetTextSize(unsigned char *Txt,s32 *DX,s32 *DY, SIZE *CharBounds = NULL);

	/* Win32 */
	virtual void Destroy() = 0; // Destroy
	virtual void AdaptTOWindow(HWND hWnd) = 0;

	virtual void DrawParticules(void *particuleList, int nbParticules, u32 TextureIndex, SIZE grid,RS *RenderState, MATRIX Orientation) = 0;
	virtual void DrawFur(void *fur, u32 TextureIndex,RS *RenderState, MATRIX Orientation, u32 debug) = 0;
	/* Matrix Overloadd */
	/* 0 = Projection , 1 = Model , 2 = Texture */
	virtual void GetMatrix(u32 Mode,float *pDest) = 0;
	virtual void SetMatrix(u32 Mode,float *pDest) = 0;


	virtual u32 GetDriverType() = 0; // "opengl" = 0 , 'D3D' = 1
};

DrawInterface *CreateOglObject(HWND Mother,u32 FrameBuffSizeX,u32 FrameBuffSizeY);
DrawInterface *CreateD3DObject(HWND Mother,u32 FrameBuffSizeX,u32 FrameBuffSizeY);
DrawInterface *CreateNulObject(HWND Mother,u32 FrameBuffSizeX,u32 FrameBuffSizeY);


/* TOOLS */
u32 GetFileLenght(char *Filename);
u32 IsExist(char *Filename);
class INPUT_IO *CreateIO(class WORLD *,char *MediaName, bool dummy = false);
class INPUT_IO *ERROR_CREATE(char *Error);
u32	GetBitReverse(u32 Value);  // Transform 0x80000000 into 0x00000001 
u32	GetBitExpand(u32 Value);   // Transform 0xFFFF into 0x55555555 
u32	GetBitContract(u32 Value); // Transform 0x55555555 into 0xFFFF

int GetLogUpperPO2(float Value);
int GetUpperPO2(float Value);
int GetFirstBit(u32 Mask);



#define SAVE_MATRIXES()\
	float _4x4_Persp[16];\
	float _4x4_Model[16];\
	float _4x4_Texture[16];\
	float FocalSave;\
	GetMatrix(0, _4x4_Persp);\
	GetMatrix(1, _4x4_Model);\
	GetMatrix(2, _4x4_Texture);\
	FocalSave = fFocUsed;

#define RESTORE_MATRIXES()\
	fFocUsed = FocalSave;\
	SetMatrix(0, _4x4_Persp);\
	SetMatrix(1, _4x4_Model);\
	SetMatrix(2, _4x4_Texture);


#define TYPE_Of_PREC float

typedef struct FFT_Complex_
{
	TYPE_Of_PREC re,im;
} FFT_Complex;

void FFT2Image(int *Picture,void *FFT,int Pitch);
void *Image2FFT(int *Picture,int SizePo2,int Pitch);

void PatchPointsToNormals(Vector *pCurves, Color4 *dstColors, u32 *srColors, int invert);
Vector PatchGetXYZFromUV(Vector *pCurves, Vector UV);
Vector PatchGetUVFromXYZ(Vector *pCurves, Vector Point, Vector vMin, Vector vMax);

#endif