/**
	DirectX9 ライブラリ

*/

#include "Dx9.h"


using namespace jbxl;
using namespace jbxwl;




LPDIRECT3D9     jbxwl::GpD3D	= NULL;
LPDIRECTINPUT8  jbxwl::GpDInput = NULL;

LPDIRECTINPUTDEVICE8  jbxwl::GpDMouse    = NULL;		// マウスのインターフェイス
LPDIRECTINPUTDEVICE8  jbxwl::GpDKeyBoard = NULL;		// キーボードのインターフェイス


BOOL  jbxwl::Dx9DividePrimitiveMode	= TRUE;				// 分割描画モード
BOOL  jbxwl::Dx9ReverseZMode		= FALSE;			// Z軸反転モード（for 3D CT）





/**
	機能：  DirectX9のデバイスへのインターフェイスを得る．
	引数：	hinst  アプリケーションのインスタンスハンドラ（通常は this->m_hInstanceを指定） 
	説明：  
*/
BOOL  jbxwl::Dx9CreateInterface(CWinApp*  wapp) 
{
	GpD3D = Direct3DCreate9(D3D_SDK_VERSION);
	if (GpD3D==NULL) {
		DEBUG_ERR("Dx9CreateInterface: グラフィックデバイスの取得に失敗しました");
		return FALSE;
	}

	HRESULT hr = DirectInput8Create(wapp->m_hInstance, DIRECTINPUT_VERSION, IID_IDirectInput8, (void**)&GpDInput, NULL);
	if (GpDInput==NULL) {
		DEBUG_ERR("Dx9CreateInterface: インプットデバイスの取得に失敗しました");
		RELEASE(GpD3D);
		return FALSE;
	}
	else {
		GpDMouse = Dx9CreateMouse(GpDInput, wapp->m_pMainWnd->m_hWnd);
		if (GpDMouse==NULL) {
			Sleep(1000);
			GpDMouse = Dx9CreateMouse(GpDInput, wapp->m_pMainWnd->m_hWnd);
			if (GpDMouse==NULL) {
				DEBUG_ERR("Dx9CreateInterface: マウスデバイスの取得に失敗しました");
				RELEASE(GpD3D);
				RELEASE(GpDInput);
				return FALSE;
			}
		}
		GpDKeyBoard = Dx9CreateKeyBoard(GpDInput, wapp->m_pMainWnd->m_hWnd);
		if (GpDKeyBoard==NULL) {
			Sleep(1000);
			GpDKeyBoard = Dx9CreateKeyBoard(GpDInput, wapp->m_pMainWnd->m_hWnd);
			if (GpDKeyBoard==NULL) {
				DEBUG_ERR("Dx9CreateInterface: キーボードデバイスの取得に失敗しました");
				RELEASE(GpDMouse);
				RELEASE(GpD3D);
				RELEASE(GpDInput);
				return FALSE;
			}
		}
	}

	return TRUE;
}






void    jbxwl::Dx9ReleaseInterface()
{
	RELEASE(GpDMouse);
	RELEASE(GpDKeyBoard);
	RELEASE(GpDInput);
	RELEASE(GpD3D);
}






/**
	機能：  DirectX9のグラフィックデバイスを得る．
	引数：	gpD3D		DirectX9のインターフェイス 
			*d3dParam	デバイス作成のためのパラメータ
			hWnd		デバイスを作成するウィンドウのウィンドウハンドル  
	戻値：  DirectX9デバイス
	説明：  
*/
LPDIRECT3DDEVICE9  jbxwl::Dx9CreateGraphic(LPDIRECT3D9 gpD3D, D3DPRESENT_PARAMETERS* d3dParam, HWND hWnd)
{
	LPDIRECT3DDEVICE9  d3dDevice=NULL;
	HRESULT hr;

	hr = gpD3D->CreateDevice(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, hWnd, D3DCREATE_HARDWARE_VERTEXPROCESSING, d3dParam, &d3dDevice);
	if (FAILED(hr)) {
		hr = gpD3D->CreateDevice(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, hWnd, D3DCREATE_SOFTWARE_VERTEXPROCESSING, d3dParam, &d3dDevice);
		if (FAILED(hr)) {
			hr = gpD3D->CreateDevice(D3DADAPTER_DEFAULT, D3DDEVTYPE_REF, hWnd, D3DCREATE_SOFTWARE_VERTEXPROCESSING, d3dParam, &d3dDevice);
			if (FAILED(hr)) return (LPDIRECT3DDEVICE9)NULL;
		}
	}
	return d3dDevice;
}








/**


*/
LPDIRECTINPUTDEVICE8  jbxwl::Dx9CreateMouse(LPDIRECTINPUT8 gpDInput, HWND hWnd)
{
	LPDIRECTINPUTDEVICE8  gpdmouse=NULL;

	HRESULT hr = gpDInput->CreateDevice(GUID_SysMouse, &gpdmouse, NULL);
	if (FAILED(hr) || gpdmouse==NULL) return NULL;

	hr = gpdmouse->SetDataFormat(&c_dfDIMouse);
	if (FAILED(hr)) return NULL;

	hr = gpdmouse->SetCooperativeLevel(hWnd, DISCL_NONEXCLUSIVE | DISCL_FOREGROUND);
	if (FAILED(hr)) return NULL;

//	軸モード 
/*	DIPROPDWORD  diprop;
	diprop.diph.dwSize = sizeof(diprop);
	diprop.diph.dwHeaderSize = sizeof(diprop.diph);
	diprop.diph.dwObj = 0;
	diprop.diph.dwHow = DIPH_DEVICE;
	diprop.dwData = DIPROPAXISMODE_ABS;
	hr = gpdmouse->SetProperty(DIPROP_AXISMODE, &diprop.diph);
	if (FAILED(hr)) {
		DEBUG_ERR("Dx9CreateMouse: SetProprty");
		return NULL;
	}
/**/

	hr = gpdmouse->Acquire();
	if (FAILED(hr)) return NULL;

	return gpdmouse;  
}





//
//  不完全  注意!!!
//
LPDIRECTINPUTDEVICE8  jbxwl::Dx9CreateKeyBoard(LPDIRECTINPUT8 gpDInput, HWND hWnd)
{
	LPDIRECTINPUTDEVICE8  gpdkeyboard=NULL;

	HRESULT hr = gpDInput->CreateDevice(GUID_SysKeyboard, &gpdkeyboard, NULL);
	if (FAILED(hr)) return NULL;

	hr = gpdkeyboard->SetDataFormat(&c_dfDIKeyboard);
	if (FAILED(hr)) return NULL;

	hr = gpdkeyboard->SetCooperativeLevel(hWnd, DISCL_NONEXCLUSIVE | DISCL_FOREGROUND);
	if (FAILED(hr)) return NULL;
	else            return gpdkeyboard;  
}








/*
	機能：  バックバッファを得る．
	引数：	gpD3DDevice		DirectX9デバイス 
			*pgpBackBuffer	獲得したバックバッファ．失敗した場合は NULL
	戻値：  バックバッファのサイズ．エラーの場合は  <0
	説明：  
*/
POINT  jbxwl::Dx9GetBackBuffer(LPDIRECT3DDEVICE9 gpD3DDevice, LPDIRECT3DSURFACE9* pgpBackBuffer)
{
	POINT  pt;
	pt.x = pt.y = -1;

	HRESULT hr = gpD3DDevice->GetBackBuffer(0, 0, D3DBACKBUFFER_TYPE_MONO, pgpBackBuffer);
	if (FAILED(hr)) return pt;

	pt = Dx9GetSurfaceSize(pgpBackBuffer);
	return pt;
}





/*
	機能：  メモリ上の cmnHeadからサーフェイスを作成する．（ラッパー関数）
	引数：	gpD3DDevice		DirectX9デバイス 
			*pgpSurface		作成したサーフェイス
			cmnhead			メモリ上のデータを記述する CmnHead 型データ．
	戻値：  実行結果の BOOL
	説明：  サポートするデータ形式は  DirectX9 (jpg, png, bmp, ......), SUN Raster, CT_DATA
			作成したサーフェイスのメモリ管理は D3DPOOL_DEFAULTになる．
*/
BOOL  jbxwl::Dx9SurfaceFromMemory(LPDIRECT3DDEVICE9 gpD3DDevice, LPDIRECT3DSURFACE9* pgpSurface, CmnHead cmnHead)
{
	BOOL ret;

	if (cmnHead.kind==HEADER_ERROR) return FALSE;
	int chk = cmnHead.kind & 0x00ff;

	if (chk==UN_KNOWN_DATA) ret = Dx9SurfaceFromMemoryFile(gpD3DDevice, pgpSurface, cmnHead);
	else					ret = Dx9SurfaceFromByteMemory(gpD3DDevice, pgpSurface, cmnHead);
	return  ret;
}




//
//	メモリ上の cmnHeadからサーフェイスを作成する．
//  DirectX9 がサポートするデータ(UN_KNOWN)用．cmnHead.grptrがメモリ上のファイル形式データを指す．
//
BOOL  jbxwl::Dx9SurfaceFromMemoryFile(LPDIRECT3DDEVICE9 gpD3DDevice, LPDIRECT3DSURFACE9* pgpSurface, CmnHead cmnHead)
{
	//HRESULT hr = gpD3DDevice->CreateOffscreenPlainSurface(
	//		cmnHead.xsize, cmnHead.ysize, (D3DFORMAT)cmnHead.depth, D3DPOOL_DEFAULT, pgpSurface, NULL);

	HRESULT hr = gpD3DDevice->CreateOffscreenPlainSurface(cmnHead.xsize, cmnHead.ysize,  D3DFMT_X8R8G8B8, D3DPOOL_DEFAULT, pgpSurface, NULL);
	if (FAILED(hr)) return FALSE;

    hr = D3DXLoadSurfaceFromFileInMemory(*pgpSurface, NULL, NULL, cmnHead.grptr, cmnHead.lsize, NULL, D3DX_FILTER_NONE, 0, (D3DXIMAGE_INFO*)cmnHead.buf);
	if (FAILED(hr)) return FALSE;

	return TRUE;
}




//
//	メモリ上の cmnHeadからサーフェイスを作成する．
//  RAS_DATA(SUN Raster), CT_DATAなどの独自ファイル用．表示データは 8bit
//
BOOL  jbxwl::Dx9SurfaceFromByteMemory(LPDIRECT3DDEVICE9 gpD3DDevice, LPDIRECT3DSURFACE9* pgpSurface, CmnHead cmnHead)
{
    HRESULT hr = gpD3DDevice->CreateOffscreenPlainSurface(cmnHead.xsize, cmnHead.ysize, D3DFMT_R5G6B5, D3DPOOL_DEFAULT, pgpSurface, NULL);
	if (FAILED(hr)) return FALSE;

	RECT    rect;
	rect.left   = 0;
	rect.top    = 0;
	rect.right  = cmnHead.xsize - 1;
	rect.bottom = cmnHead.ysize - 1;
    hr = D3DXLoadSurfaceFromMemory(*pgpSurface, NULL, NULL, cmnHead.grptr, D3DFMT_L8,  cmnHead.xsize, NULL, &rect, D3DX_FILTER_NONE, 0);
//	hr = D3DXLoadSurfaceFromMemory(*pgpSurface, NULL, NULL, cmnHead.grptr, D3DFMT_L16, cmnHead.xsize*2, NULL, &rect, D3DX_FILTER_NONE, 0);
	if (FAILED(hr)) return FALSE;
	return TRUE;
}





/*
	機能：  メモリ上の cmnHeadからテクスチャを作成する．（ラッパー関数）
	引数：	gpD3DDevice		DirectX9デバイス 
			*pgpSurface		作成したテクスチャ
			cmnhead			メモリ上のデータを記述する CmnHead 型データ．
	戻値：  実行結果の BOOL
	説明：  サポートするデータ形式は  DirectX9 (jpg, png, bmp, ......), SUN Raster, CT_DATA
			作成したテクスチャのメモリ管理は D3DPOOL_DEFAULTになる．
*/
BOOL  jbxwl::Dx9TextureFromMemory(LPDIRECT3DDEVICE9 gpD3DDevice, LPDIRECT3DTEXTURE9* pgpTexture, CmnHead cmnHead)
{
	BOOL ret;

	if (cmnHead.kind==HEADER_ERROR) return FALSE;
	int chk = cmnHead.kind & 0x00ff;

	if (chk==UN_KNOWN_DATA) ret = Dx9TextureFromMemoryFile(gpD3DDevice, pgpTexture, cmnHead);
	else					ret = Dx9TextureFromByteMemory(gpD3DDevice, pgpTexture, cmnHead);
	return  ret;
}





//
//	メモリ上の cmnHeadからテクスチャを作成する．
//  DirectX9 がサポートするデータ(UN_KNOWN)用．cmnHead.grptrがメモリ上のファイル形式データを指す．
//
BOOL  jbxwl::Dx9TextureFromMemoryFile(LPDIRECT3DDEVICE9 gpD3DDevice, LPDIRECT3DTEXTURE9* pgpTexture, CmnHead cmnHead)
{
	HRESULT	hr = D3DXCreateTextureFromFileInMemoryEx(
				gpD3DDevice, cmnHead.grptr, cmnHead.lsize, 0, 0, 0, 0, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, //D3DPOOL_MANAGED, 
				D3DX_FILTER_LINEAR, D3DX_FILTER_LINEAR, 0, NULL, NULL, pgpTexture);
	if (FAILED(hr)) return FALSE;
	return  TRUE;
}





//
//	メモリ上の cmnHeadからテクスチャを作成する．
//  RAS_DATA(SUN Raster), CT_DATAなどの独自ファイル用．テクスチャデータは 8bit
//
BOOL  jbxwl::Dx9TextureFromByteMemory(LPDIRECT3DDEVICE9 gpD3DDevice, LPDIRECT3DTEXTURE9* pgpTexture, CmnHead cmnHead)
{
	HRESULT hr;
	RECT    rect;
	LPDIRECT3DSURFACE9 surface;

	hr = D3DXCreateTexture(gpD3DDevice, cmnHead.xsize, cmnHead.ysize, 0, D3DUSAGE_RENDERTARGET, D3DFMT_L8, D3DPOOL_DEFAULT, pgpTexture);
	if (FAILED(hr)) return FALSE; 

	hr = (*pgpTexture)->GetSurfaceLevel(0, &surface);
	if (FAILED(hr)) return FALSE; 

	rect.left   = 0;
	rect.top    = 0;
	rect.right  = cmnHead.xsize - 1;
	rect.bottom = cmnHead.ysize - 1;
	hr = D3DXLoadSurfaceFromMemory(surface, NULL, NULL, cmnHead.grptr, D3DFMT_L8, cmnHead.xsize, NULL, &rect, D3DX_FILTER_LINEAR, 0);
	RELEASE(surface);

	if (FAILED(hr)) return FALSE;
	return TRUE;
}





/*
	機能：  DrawPrimitiveのラッパー．Dx9DividePrimitiveModeが TRUEの時，
	        数回に分けて DrawPrimitiveを呼び出す．

	引数：	gpD3DDevice		DirectX9デバイス 
			ptyepe			プリミティブタイプ
			unit			１個のプリミティブを書くために必要な頂点数．
			bsize			プリミティブの数

	戻値：  実行結果の HRESULT

	説明：  ある種のカード は Primitiveの数が多いと誤作動する場合があるので，
			MAXPRIMITIVE個ずつ分けて表示する．
*/
HRESULT  jbxwl::Dx9DrawPrimitive(LPDIRECT3DDEVICE9 gpD3DDevice, D3DPRIMITIVETYPE ptype, UINT unit, UINT bsize)
{
	HRESULT hr;
	
	if (Dx9DividePrimitiveMode) {	// 分割描画モード
		UINT  iter = bsize / MAXPRIMITIVE;
		UINT  imod = bsize % MAXPRIMITIVE;

		unsigned int i;
		for (i=0; i<iter; i++) {
			hr = gpD3DDevice->DrawPrimitive(ptype, i*unit*MAXPRIMITIVE, MAXPRIMITIVE);
			if (FAILED(hr)) return hr;
		}
		hr = gpD3DDevice->DrawPrimitive(ptype, i*unit*MAXPRIMITIVE, imod);
		//if (FAILED(hr)) Dx9DividePrimitiveMode = FALSE;                 
	}
	else {							// ノーマルモード
		hr = gpD3DDevice->DrawPrimitive(ptype, 0, bsize);
		//if (FAILED(hr)) Dx9DividePrimitiveMode = TRUE;                 
	}

	return hr;
}









POINT  jbxwl::Dx9GetSurfaceSize(LPDIRECT3DSURFACE9* lpsf)
{
	D3DSURFACE_DESC  desc;
	POINT  pt;

	(*lpsf)->GetDesc(&desc);
	pt.x = desc.Width;
	pt.y = desc.Height;

	return pt;
}















