#include "DxLib.h"

enum{//OSのバージョンを取得するための列挙
	enuWindows3_1=0,
	enuWindowsNT3_51,
	enuWindowsNT4_0,
	enuWindows95,
	enuWindows98,
	enuWindows2000,
	enuWindowsMe,
	enuWindowsXP
};


class _DGC{
protected:
	char *SoftName;//SetWindowText
	char *PauseGraphName;//LoadPauseGraph( PaiseGraphName )
	bool LogFlag;//TRUEでログ出力中　SetOutApplicationLogValidFlag
	bool _3DFlag;//TRUEで3D使用中　SetUse3DFlag
	bool VSyncFlag;//TRUEでCRT垂直同期信号を待つ
	bool BasicBlendFlag;//TRUEでブレンドモードの簡略化
	bool ScreenSystemMemory;//TRUEでシステムメモリに裏画面を置いている　SetScreenMemToVramFlag( SMemFlag )
	bool NowSetUseVramFlag;
	int SetTransColor_Red;
	int SetTransColor_Green;
	int SetTransColor_Blue;
	int NowGraphColorBitDepth;//SetGraphColorBitDepth_( int ColorBitDepth ){
	int SetUseGraphAlphaChannel_Flag;//SetUseGraphAlphaChannel(  UseFlag ) ;
	int ChangeWindowModeResult;//ChangeWindowMode( WindowModeFlag )でどのような値が帰ったか？
	int ScreenX;//SetGraphMode(SizeXValue;
	int ScreenY;//SetGraphMode(SizeYValue;
	int ColorBitDepth;//SetGraphMode(ColorBitNum;
	int SetGraphModeResult;//SetGraphModeの戻り値保存
	bool MouseDisplayFlag;//SetMouseDispFlag( MouseDispFlag ))// マウスの表示フラグのセット
	int SRandNumber;//The argument of Srand Function
	int SetDrawModeType;//The state of SetDrawMode
	int SetDrawBlendMode_BlendType;//The state of the argument of SetBlendMode BlendMode
	int SetDrawBlendMode_Pal;//The State of the argument of SetBlendMode Pal
	int RedBright;//The State of the Argument RedBright of SetDrawBrigt
	int GreenBright;//The State of the Argument GreenBright of SetDrawBright
	int BlueBright;//The State of the Argument BlueBright of SetDrawBright
	int NowFontSize;//The State of Argument of SetFontSize
	int NowFontThickness;//The State of Argument of SetFontThickness;
	RECT NowDrawArea;//The State of Argument of SetDrawArea( int x1 , int y1 , int x2 , int y2 ){
	int NowDrawScreen;//The State of The return value of SetDrawScreen;
	bool NowUseMaskScreenFlag;//The State of Argument of SetUseMaskScreenFlag;

	int _FPS;//The Count of the FPS Value
	int _FPS_Count;
	int _FPS_Time;

	bool _debug;
			//変数
	int _NowMousePointX,_NowMousePointY;//今のマウス座標を保存
	bool _NoDxlibEnd;//trueでDxlibを任意終了してないDxlibInitでtrueにDxlibEndでフラグをfalseにする
public:
	
	//関数のポインタ
	int (*printfDx)( char *FormatString , ... );
	int (*DrawFormatStringToHandle)(int x,int y,int Color,int FontHandle,char *FormatString, ... );	// 書式指定文字列を描画する
	//コンストラクタ
	_DGC(){
		
		printfDx=printfDx;//関数のポインタ格納ってヤツ
		DrawFormatStringToHandle = DrawFormatStringToHandle;

		//memset(&SoftName,sizeof(char)*256,0);///SetWindowText
		//ZeroMemory(&PauseGraphName,sizeof(char)*256);//LoadPauseGraph( PaiseGraphName )
		SoftName=NULL;
		PauseGraphName=NULL;
		//bool LogFlag;//TRUEでログ出力中　SetOutApplicationLogValidFlag
		//bool _3DFlag;//TRUEで3D使用中　SetUse3DFlag
		 VSyncFlag=true;//通常は待つよってTRUE　TRUEでCRT垂直同期信号を待つ
		 BasicBlendFlag=false;//デフォルトはfalse　TRUEでブレンドモードの簡略化
		 ScreenSystemMemory=false;//TRUEでシステムメモリに裏画面を置いている　SetScreenMemToVramFlag( SMemFlag )
		 NowSetUseVramFlag=true;
			
		 SetTransColor_Red=-1000;//すべて未使用
		 SetTransColor_Green=-1000;
		 SetTransColor_Blue=-1000;
		 NowGraphColorBitDepth=-1000;//SetGraphColorBitDepth_( int ColorBitDepth ){
		 SetUseGraphAlphaChannel_Flag=-1000;//SetUseGraphAlphaChannel(  UseFlag ) ;
		 ChangeWindowModeResult=-1000;//ChangeWindowMode( WindowModeFlag )でどのような値が帰ったか？
		
		 ScreenX=640;//SetGraphMode(SizeXValue;
		 ScreenY=480;//SetGraphMode(SizeYValue;
		 ColorBitDepth=16;//SetGraphMode(ColorBitNum;

		 SetGraphModeResult=-1000;//SetGraphModeの戻り値保存
		 MouseDisplayFlag=false;//SetMouseDispFlag( MouseDispFlag ))// マウスの表示フラグのセット
		
		 SRandNumber=-1000;//The argument of Srand Function
		 SetDrawModeType=DX_DRAWMODE_NEAREST;//The state of SetDrawMode
		SetDrawBlendMode_BlendType=DX_BLENDMODE_NOBLEND;//The state of the argument of SetBlendMode BlendMode
		SetDrawBlendMode_Pal=-1000;//The State of the argument of SetBlendMode Pal
		 RedBright=255;//The State of the Argument RedBright of SetDrawBrigt
		 GreenBright=255;//The State of the Argument GreenBright of SetDrawBright
		 BlueBright=255;//The State of the Argument BlueBright of SetDrawBright
		 NowFontSize=-1000;//The State of Argument of SetFontSize
		 NowFontThickness=-1000;//The State of Argument of SetFontThickness;
		 NowDrawArea.left=0;
		 NowDrawArea.top=0;
		 NowDrawArea.right=ScreenX;
		 NowDrawArea.bottom=ScreenY;//The State of Argument of SetDrawArea( int x1 , int y1 , int x2 , int y2 ){
		 NowDrawScreen=DX_SCREEN_FRONT;//The State of The return value of SetDrawScreen;
		NowUseMaskScreenFlag=false;//The State of Argument of SetUseMaskScreenFlag;

		 _FPS=0;//The Count of the FPS Value
		_FPS_Count=0;
		_FPS_Time=0;

		_NowMousePointX=0;
		_NowMousePointY=0;

		_NoDxlibEnd=false;
		_debug=true;
		

	}
	//デストラクタ
	~_DGC(){
		if(_NoDxlibEnd==true){
			DxLib_End();
		}
		if(SoftName !=NULL){
			free(SoftName);
		}
		if(PauseGraphName !=NULL){
			free(PauseGraphName);
		}
	
	}

	bool DxlibInit(int SizeX,//画面領域の(横)Xのサイズを設定640がﾒｼﾞｬｰ
					int SizeY,//画面領域の(縦)Yのサイズを設定480がﾒｼﾞｬｰ
					int ColorBitNum,//BitDepthを設定8か16か32です。
					char *WindowText,//ソフトの名前
					int WindowModeFlag=FALSE,//TRUEでWindowMode
					char *PaiseGraphName=NULL,//画像の名前を入れると否アクティブ時のグラフィックを表示する
					int MouseDispFlag=FALSE,//TRUEでマウスのカーソルを表示
					int DrawDisplayFlag=DX_SCREEN_BACK,//裏画面に描画か、表画面に描画か？
					int _3DFlag=TRUE,//FALSEで3D機能を使わない
					int SMemFlag=FALSE,//TRUEで裏画面をシステムメモリにする
					int BBlendFlag=FALSE,//TRUEブレンドモードを簡略化する
					int VSyncFlag=TRUE,//FALSEでＣＲＴの垂直同期信号を待たない
					int LogFlag=TRUE,//TRUEでログを出力する
					int RandMax=NULL//別に設定しなくて良い
	){
		if(-1==SetWindowText_( WindowText ))//Windowの名前を変更
			return false;
		if(-1==SetOutApplicationLogValidFlag_(  LogFlag ))//ログの出力を行うか否か
			return false;
		if(-1== SetUse3DFlag_( _3DFlag ))//3DGraphicボードの機能を使うか否か
			return false;
		if(-1==SetWaitVSyncFlag_( VSyncFlag ))//CRTの垂直同期信号を待つか否か
			return false;
		if(-1==SetBasicBlendFlag_(  BBlendFlag ))//ブレンドモードの簡略化
			return false;
		if(-1==SetScreenMemToVramFlag_( SMemFlag ))//描画するところをシステムメモリにするかいなか
			return false;
		if(DX_CHANGESCREEN_OK != ChangeWindowMode_( WindowModeFlag ))//WindowMode or FullScreenMode?
			return false;
		if(-1==LoadPauseGraph_( PaiseGraphName ))//Windowがアクティブじゃないときに表示するGraphic
			return false;
		if(DX_CHANGESCREEN_OK != SetGraphMode_(  SizeX ,  SizeY ,  ColorBitNum ))//Change Screen Size!
			return false;
		if(-1==SetMouseDispFlag_( MouseDispFlag ))// マウスの表示フラグのセット
			return false;
		if(-1==DxLib_Init())//初期化
			return false;
		if(-1==SetDrawScreen_(DrawDisplayFlag))
			return false;

		_NoDxlibEnd = true;//DxlibIniｔは終了のフラグを立てる

		if(RandMax !=NULL){//乱数初期化
			SRand_(RandMax);
		}
		//３D機能を使っているか点検
		if(TRUE == GetUse3DFlag_())
			_3DFlag=true;//TRUEで3D使用中　SetUse3DFlag
		else
			_3DFlag=false;

		return true;

	}
	bool DxlibEnd(){
		DxLib_End() ;// ＤＸライブラリ使用の終了処理
		_NoDxlibEnd = false;//Dxlibは任意終了したフラグを立てる
		return true;
	}
	
	//基本描画系
	int DrawLine_(int x1,int y1,int x2,int y2,int Color){
		return DrawLine(x1,y1,x2,y2,Color);
	}
	int	DrawPixelSet_( POINTDATA *PointData , int Num ){
		return DrawPixelSet( PointData , Num );// 点の集合を描く
	}
	int	DrawLineSet( LINEDATA *LineData , int Num ){
		return DrawLineSet( LineData , Num );// 線の集合を描く
	}
	int DrawBox_( int x1 , int y1 , int x2 , int y2 ,int Color , int FillFlag ){
		return DrawBox(x1,y1,x2,y2,Color,FillFlag);//四角形の中身ぬり？
	}

	int	DrawLineBox_( int x1 , int y1 , int x2 , int y2 , int Color ){
		return DrawLineBox(x1, y1, x2 ,y2,Color );// 四角形の描画 
	}

	int	DrawFillBox_( int x1 , int y1 , int x2 , int y2 , int Color ){
		return DrawFillBox( x1 , y1 ,  x2 ,y2 ,Color );// 中身のある四角を描画
	}
	int DrawCircle_( int x , int y , int r , int Color, int FillFlag ){
		return DrawCircle(x , y ,r ,Color,FillFlag);
	}
	int DrawOval_( int x , int y , int rx , int ry , int Color , int FillFlag ){
		return DrawOval(x ,y ,rx ,ry,Color,FillFlag ) ;
	}
	int DrawPixel_( int x , int y , int Color ){
		return DrawPixel(  x , y , Color ) ;
	}
	//取得系
	int GetPixel_( int x , int y ){
		return GetPixel(x , y ) ;
		
	}
	//ロード系
		//画像
	int GraphScreen_( int x , int y , char *GraphName , int TransFlag ){
		return LoadGraphScreen(x ,y , GraphName , TransFlag ) ;
	}
	int LoadGraph_( char *FileName ){
		return LoadGraph( FileName ) ;
	}
	void LoadGraphArgument(char *filename,int *Handle){
		*Handle = LoadGraph(filename);
	}
	int LoadDivGraph_( char *FileName , int AllNum ,
					int XNum , int YNum ,
					int XSize , int YSize , int *HandleBuf ){
		return LoadDivGraph(FileName,AllNum,XNum,YNum,XSize,YSize,HandleBuf);
	}
	int ReloadGraph_( char *FileName , int GrHandle ){
		return ReloadGraph( FileName , GrHandle ) ;
	}
	int ReloadDivGraph_( char *FileName , int AllNum ,int XNum , int YNum ,
		int XSize, int YSize, int *HandleBuf )
	{
		return ReloadDivGraph( FileName,AllNum, XNum ,YNum ,XSize,YSize,HandleBuf) ;
	}
	int MakeGraph_( int SizeX , int SizeY ){
		return MakeGraph( SizeX ,  SizeY ) ;
	}

	int GetDrawScreenGraph_( int x1 , int y1 ,int x2, int y2, int GrHandle ){
		return GetDrawScreenGraph( x1 , y1 , x2, y2, GrHandle );
	}

	int GetGraphSize_( int GrHandle ,int *SizeXBuf , int *SizeYBuf ){
		return GetGraphSize( GrHandle , SizeXBuf , SizeYBuf );
	}
	int InitGraph_( void ){//画像初期化
		return InitGraph( ) ;
	}
	int DeleteGraph_( int GrHandle ){//画像削除
		return DeleteGraph( GrHandle ) ;
	}

	int SetDrawMode_( int DrawMode ){
		SetDrawModeType=DrawMode;//The state of SetDrawMode
	
		return SetDrawMode(DrawMode ) ;
	}
	int SetDrawBlendMode_( int BlendMode , int Pal ){//ブレンドモード
		SetDrawBlendMode_BlendType=BlendMode;//The state of the argument of SetBlendMode BlendMode
		SetDrawBlendMode_Pal=Pal;//The State of the argument of SetBlendMode Pal
			
		return SetDrawBlendMode( BlendMode ,Pal ) ;
	}
	int SetDrawBright_( int RedBright ,int GreenBright ,int BlueBright ){//描画彩度
		RedBright=RedBright;//The State of the Argument RedBright of SetDrawBrigt
		GreenBright=GreenBright;//The State of the Argument GreenBright of SetDrawBright
		BlueBright=BlueBright;//The State of the Argument BlueBright of SetDrawBright
		
		return SetDrawBright( RedBright , GreenBright , BlueBright ) ;
	}

	//文字列系
	int GetDrawStringWidth_( char *String , int StrLen ){
		return GetDrawStringWidth_(String , StrLen ) ;
	}
	int GetDrawFormatStringWidth_( char *FormatString , ... ){
		va_list VaList ;
		char String[ 1024 ] ;
		va_start( VaList , FormatString ) ;
		vsprintf( String , FormatString , VaList ) ;
		va_end( VaList ) ;
		return GetDrawStringWidthToHandle( String , lstrlen( String ) , GetDefaultFontHandle() ) ;
	}
	int SetFontSize_( int FontSize ){
		 NowFontSize=FontSize;//The State of Argument of SetFontSize
	
		return SetFontSize( FontSize ) ;
	}
	int SetFontThickness_( int TinckPal ){
		NowFontThickness=TinckPal;//The State of Argument of SetFontThickness;
		return SetFontThickness(TinckPal ) ;
	}
	int ChangeFont_( char *FontName ){//FontChange
		return ChangeFont( FontName ) ;
	}
	int ChangeFontType_( int FontType ){
		return ChangeFontType( FontType ) ;
	}
	int CreateFontToHandle_( char *FontName , int Size , int Thinck , int FontType ){
		return CreateFontToHandle(FontName , Size , Thinck ,  FontType ) ;
	}
	int DeleteFontToHandle_( int FontHandle ){
		return DeleteFontToHandle( FontHandle ) ;
	}
	int GetDrawStringWidthToHandle_( char *String ,int StrLen , int FontHandle ){
		return GetDrawStringWidthToHandle(String ,StrLen ,  FontHandle ) ;
	}
	int GetDrawFormatStringWidthToHandle_(int FontHandle ,char *FormatString , ... ){
		va_list VaList ;
		char String[ 1024 ] ;
		va_start( VaList , FormatString ) ;
		vsprintf( String , FormatString , VaList ) ;
		va_end( VaList ) ;
		return GetDrawStringWidthToHandle( String , lstrlen( String ) , FontHandle ) ;
	}
	int GetFontStateToHandle_( char *FontName , int *Size ,int *Thinck , int FontHandle ){
		return GetFontStateToHandle(FontName ,Size ,Thinck ,FontHandle ) ;
	}
	int InitFontToHandle_( void ){
		return InitFontToHandle( ) ;
	}

	//文字描画系																		
	int	DrawString_( int x , int y , char *String , int Color , int EdgeColor = 0 ){
		return	DrawString(x , y ,String , Color , EdgeColor);// 文字列の描画
	}
	int	DrawStringToHandle_( int x , int y , char *String , int Color , int FontHandle , int EdgeColor = 0 ){
		return DrawStringToHandle(x,y ,String ,Color ,FontHandle ,EdgeColor );// 文字列を描画する
	}
	int DrawFormatString_( int x , int y , int Color , char *FormatString , ... ){
		va_list VaList ;
		char String[ 1024 ] ;
		va_start( VaList , FormatString ) ;
		vsprintf( String , FormatString , VaList ) ;
		va_end( VaList ) ;
		return DrawStringToHandle( x , y , String , Color , GetDefaultFontHandle() ) ;
	}

	//関数のポインタ予定int	DrawFormatStringToHandle_( int x , int y , int Color , int FontHandle , char *FormatString , ... ){	// 書式指定文字列を描画する

	int	DrawNumberToI_( int x , int y , int Num , int RisesNum , int Color ,int EdgeColor = 0 ){
		return DrawNumberToI( x ,y ,Num ,RisesNum ,Color ,EdgeColor);// 整数型の数値を描画する
	}
	int	DrawNumberToF_( int x , int y , double Num , int Length , int Color ,int EdgeColor = 0 ){
		return DrawNumberToF(x ,y ,Num ,Length ,Color ,EdgeColor );// 浮動小数点型の数値を描画する
	}
	int	DrawNumberPlusToI_( int x, int y , char *NoteString , int Num , int RisesNum , int Color,int EdgeColor = 0 ){// 整数型の数値とその説明の文字列を一度に描画する
		return DrawNumberPlusToI(x,y ,NoteString ,Num ,RisesNum ,Color,EdgeColor);// 整数型の数値とその説明の文字列を一度に描画する
	}
	int	DrawNumberPlusToF_( int x, int y , char *NoteString , double Num , int Length , int Color,int EdgeColor = 0 ){
		return DrawNumberPlusToF(x,y ,NoteString ,Num ,Length ,Color,EdgeColor ) ;// 浮動小数点型の数値とその説明の文字列を一度に描画する
	}

	int	DrawNumberToIToHandle_( int x , int y , int Num , int RisesNum , int Color , int FontHandle,int EdgeColor = 0 ){
		return DrawNumberToIToHandle(x ,y ,Num ,RisesNum ,Color ,FontHandle,EdgeColor) ;// 整数型の数値を描画する
	}
	int	DrawNumberToFToHandle_( int x , int y , double Num , int Length , int Color , int FontHandle,int EdgeColor = 0 ){
		return	DrawNumberToFToHandle(x ,y ,Num ,Length ,Color ,FontHandle,EdgeColor ) ;// 浮動小数点型の数値を描画する
	}
	int	DrawNumberPlusToIToHandle_( int x, int y , char *NoteString , int Num , int RisesNum , int Color , int FontHandle,int EdgeColor = 0 ){
		return	DrawNumberPlusToIToHandle(  x, y , NoteString , Num , RisesNum , Color , FontHandle,EdgeColor);// 整数型の数値とその説明の文字列を一度に描画する
	}
	int	DrawNumberPlusToFToHandle_( int x, int y , char *NoteString , double Num , int Length , int Color , int FontHandle,int EdgeColor = 0 ){
		return	DrawNumberPlusToFToHandle( x, y , NoteString ,  Num , Length , Color , FontHandle,EdgeColor ) ;	// 浮動小数点型の数値とその説明の文字列を一度に描画する// 浮動小数点型の数値とその説明の文字列を一度に描画する
	}
	//簡易でバック出力系
	//関数のポインタint printfDx_( char *FormatString , ... ){
	
	int clsDx_(void){
		return clsDx() ;
	}
	//その他系
	int SetGraphMode_( int SizeX , int SizeY , int ColorBitNum ){
		int ScreenX=SizeX;//SetGraphMode(SizeXValue;
		int ScreenY=SizeY;//SetGraphMode(SizeYValue;
		int ColorBitDepth=ColorBitNum;//SetGraphMode(ColorBitNum;
	
		return SetGraphModeResult=SetGraphMode(SizeX ,SizeY , ColorBitNum ) ;
	}
	int GetScreenState_( int *SizeX , int *SizeY , int *ColorBitDepth ){
		return GetScreenState(SizeX , SizeY , ColorBitDepth ) ;
	}
	int SetDrawArea_( int x1 , int y1 , int x2 , int y2 ){
		NowDrawArea.left=x1;//The State of Argument of SetDrawArea( int x1 , int y1 , int x2 , int y2 ){
		NowDrawArea.top=y1;
		NowDrawArea.right=x2;
		NowDrawArea.bottom=y2;

		
		return SetDrawArea(x1 , y1 ,x2 ,y2 ) ;
	}
	int GetColor_( int Red , int Green , int Blue ){
		return GetColor(Red , Green ,Blue ) ;
	}
	int SetDrawScreen_( int DrawScreen ){
		NowDrawScreen=DrawScreen;//The State of The return value of SetDrawScreen;
	
		return SetDrawScreen( DrawScreen ) ;
	}
	int ScreenFlip_( void ){
		return ScreenFlip( ) ;
	}

	//マスク系
	int CreateMaskScreen_( void ){
		return CreateMaskScreen() ;
	}
	int DeleteMaskScreen_( void ){
		return DeleteMaskScreen() ;
	}
	int LoadMask_( char *FileName ){
		return LoadMask(FileName ) ;
	}
	void LoadMaskArgument(char *f,int *handle){
		*handle = LoadMask(f);
	}
	int LoadDivMask_( char *FileName , int AllNum , int XNum , int YNum ,
		int XSize , int YSize , int *HandleBuf ){
		
		return LoadDivMask( FileName , AllNum , XNum , YNum ,XSize ,YSize , HandleBuf ) ;
	}
	int DrawMask_( int x , int y , int MaskHandle , int TransMode ){
		return DrawMask( x , y , MaskHandle ,TransMode ) ;
	}
	int DrawFillMask_( int x1 , int y1 , int x2 , int y2 , int MaskHandle ){
		return DrawFillMask(x1 , y1 ,x2 , y2 , MaskHandle ) ;
	}
	int DeleteMask_( int MaskHandle ){
		return DeleteMask( MaskHandle ) ;
	}
	int InitMask_( void ){
		NowUseMaskScreenFlag=true;//マスク使用中
		return InitMask();
	}
	int FillMaskScreen_( int Flag ){
		return FillMaskScreen( Flag ) ;
	}
	int SetUseMaskScreenFlag_( int ValidFlag ){
		if(FALSE==ValidFlag)
			NowUseMaskScreenFlag=false;//The State of Argument of SetUseMaskScreenFlag;
		else
			NowUseMaskScreenFlag=true;

		return SetUseMaskScreenFlag(ValidFlag ) ;
	}
	int MakeMask_( int Width , int Height ){
		return MakeMask( Width , Height ) ;
	}
	int GetMaskSize_( int *WidthBuf , int *HeightBuf , int MaskHandle ){
		return GetMaskSize(WidthBuf ,HeightBuf , MaskHandle ) ;
	}
	int SetDataToMask_( int Width , int Height ,void *MaskData , int MaskHandle ){
		return SetDataToMask( Width , Height ,MaskData , MaskHandle ) ;
	}
	int DrawMaskToDirectData_( 
		int x , int y ,int Width , int Height ,void *MaskData , int TransMode
		){
		return DrawMaskToDirectData( x , y ,Width ,Height ,MaskData ,TransMode );
	}
	int DrawFillMaskToDirectData_(
		int x1, int y1, int x2, int y2,int Width, int Height, void *MaskData
		){
		return DrawFillMaskToDirectData(x1,y1,x2,y2,Width,Height,MaskData ) ;
	}
	//ジョイパッド系
	int GetJoypadNum_( void ){
		return  GetJoypadNum( ) ;
	}
	int GetJoypadInputState_( int InputType ){
		return GetJoypadInputState(InputType ) ;
	}
	int GetJoypadAnalogInput_( int *XBuf , int *YBuf , int InputType){
		return GetJoypadAnalogInput(XBuf ,YBuf ,InputType) ;
	}
	//マウス系

		
	int SetMouseDispFlag_( int DispFlag ){
		if(FALSE==DispFlag)
			MouseDisplayFlag=false;
		else
			MouseDisplayFlag=true;

		return SetMouseDispFlag( DispFlag );
	}
	int GetMousePoint_( int *XBuf, int *YBuf ){
		static int _GetMousePointReturnValue=0;
		_GetMousePointReturnValue = GetMousePoint(XBuf,YBuf );
		_NowMousePointX=*XBuf;//X座標保存
		_NowMousePointY=*YBuf;//Y座標保存
		return _GetMousePointReturnValue;
	}
	int SetMousePoint_( int PointX , int PointY ){
		_NowMousePointX=PointX;//X保存
		_NowMousePointY=PointY;//Y保存
		return SetMousePoint(PointX ,PointY );
	}
	
	int GetMouseInput_( void ){
		return GetMouseInput() ;
	}
	//独自関数マウスの座標を描画する
	int _DrawMousePointValue(int x,int y,int color, char *str...){
		char s[1024];
		sprintf(s," X=%d Y=%d",x,y);
		strcat(str,s);
		va_list VaList ;
		va_start( VaList , str ) ;
		vsprintf( s , str , VaList ) ;
		va_end( VaList ) ;
		return DrawString_(x,y,s,color);
	}
	//キーボード系
	int CheckHitKeyAll_( void ){
		return CheckHitKeyAll() ;
	}
	int CheckHitKey_( int KeyCode ){
		return CheckHitKey(  KeyCode ) ;
	}
	int GetHitKeyStateAll_( char *KeyStateBuf ){
		return GetHitKeyStateAll( KeyStateBuf ) ;
	}
	//文字入力系
	char GetInputChar_( int DeleteFlag ){
		return GetInputChar(  DeleteFlag ) ;
	}
	char GetInputCharWait_( int DeleteFlag ){
		return GetInputCharWait( DeleteFlag ) ;
	}
	int ClearInputCharBuf_( void ){
		return ClearInputCharBuf( ) ;
	}
	int KeyInputString_( int x , int y ,int CharMaxLength , 
		char *StrBuffer ,int CancelValidFlag ){

		return KeyInputString(x,y ,CharMaxLength ,StrBuffer ,CancelValidFlag ) ; 
	}
	int KeyInputSingleCharString_( int x , int y , int CharMaxLength ,
		char *StrBuffer , int CancelValidFlag ){

		return  KeyInputSingleCharString_(x ,y ,CharMaxLength ,
			StrBuffer ,CancelValidFlag ) ;
	}

	int KeyInputNumber_( int x , int y , int MaxNum , int MinNum ,int CancelValidFlag ){
		return KeyInputNumber(x ,y ,MaxNum ,MinNum ,CancelValidFlag ) ;
	}
	int SetKeyInputStringColor_( int NmlStr , int NmlCur ,int IMEStr , int IMECur ,
		int IMELine , int IMESelectStr ,int IMEModeStr ){
		
		return  SetKeyInputStringColor( NmlStr ,NmlCur ,IMEStr ,IMECur ,
			IMELine ,IMESelectStr ,IMEModeStr ) ;
	}
	int MakeKeyInput_( int MaxStrLength , int CancelValidFlag ,
		int SingleCharOnlyFlag , int NumCharOnlyFlag ){
		
		return MakeKeyInput( MaxStrLength ,CancelValidFlag ,
			SingleCharOnlyFlag ,NumCharOnlyFlag ) ;
	}
	int DeleteKeyInput_( int InputHandle ){
		return DeleteKeyInput(InputHandle ) ;
	}

	int InitKeyInput_( void ){
		return InitKeyInput(  ) ;
	}
	int SetActiveKeyInput_( int InputHandle ){
		return SetActiveKeyInput(InputHandle ) ;
	}
	int CheckKeyInput_( int InputHandle ){
		return CheckKeyInput( InputHandle ) ;
	}
		//入力文字描画系
	int DrawKeyInputString_( int x , int y , int InputHandle ){

		return DrawKeyInputString(x ,y , InputHandle ) ;
	}
	int DrawKeyInputModeString_( int x , int y ){
		return DrawKeyInputModeString(x , y ) ;
	}
		//文字列セット系
	int SetKeyInputString_( char *String , int InputHandle ){
		return SetKeyInputString(String ,InputHandle ) ;
	}
	int SetKeyInputNumber_( int Number , int InputHandle ){
		return SetKeyInputNumber(Number ,InputHandle ) ;
	}
		//文字列取得系
	int GetKeyInputString_( char *StrBuffer , int InputHandle ){
		return GetKeyInputString(StrBuffer ,InputHandle ) ;
	}
	int GetKeyInputNumber_( int InputHandle ){
		return GetKeyInputNumber( InputHandle ) ;
	}
	//Wait系
	int WaitTimer_( int WaitTime ){
		return WaitTimer( WaitTime ) ;
	}
	int WaitVSync_( int SyncNum ){
		return  WaitVSync( SyncNum ) ;
	}
	int WaitKey_( void ){
		return  WaitKey(  ) ;
	}
	//時間系
	int GetNowCount_( void ){
		return GetNowCount( ) ;
	}
	void GetNowCountArgument(int *Count){
		*Count = GetNowCount();
	}
	LONGLONG GetNowHiPerformanceCount_( void ){
		return GetNowHiPerformanceCount( ) ;
	}
	void GetNowHiPerfomanceCountArgument(LONGLONG *Count){
		*Count = GetNowHiPerformanceCount( ) ;
	}
	int GetDateTime_( DATEDATA *DateBuf ){
		return  GetDateTime( DateBuf ) ;
	}
	//音　効果音　Sound系
	int PlaySound_( char *FileName , int PlayType ){
		return PlaySound( FileName ,PlayType ) ;
	}
	int CheckSound_( void ){
		return CheckSound() ;
	}
	int StopSound_( void ){
		return StopSound() ;
	}
	int LoadSoundMem_( char *FileName ){
		return LoadSoundMem(FileName ) ;
	}
	void LoadSoundMemArgument(char *f,int *handle){
		*handle = LoadSoundMem(f);
	}
	
	int PlaySoundMem_( int SoundHandle , int PlayType ){
		return  PlaySoundMem(SoundHandle , PlayType ) ;
	}
	int CheckSoundMem_( int SoundHandle ){
		return CheckSoundMem( SoundHandle ) ;
	}
	int StopSoundMem_( int SoundHandle ){
		return StopSoundMem(SoundHandle ) ;
	}
	int DeleteSoundMem_( int SoundHandle ){
		return DeleteSoundMem( SoundHandle ) ;
	}
	int InitSoundMem_( void ){
		return InitSoundMem( ) ;
	}
	int SetPanSoundMem_( int PanPal , int SoundHandle ){
		return SetPanSoundMem( PanPal , SoundHandle ) ;
	}
	int SetVolumeSoundMem_( int VolumePal , int SoundHandle ){
		return SetVolumeSoundMem( VolumePal , SoundHandle ) ;
	}
	int SetFrequencySoundMem_( int FrequencyPal , int SoundHandle ){
		return SetFrequencySoundMem( FrequencyPal ,SoundHandle ) ;
	}
	int LoadSoundMem2_( char *WaveName1 , char *WaveName2 ){
		return  LoadSoundMem2( WaveName1 , WaveName2 ) ;
	}
	void LoadSoundMemArgument(char *wf1,char *wf2,int *handle){
		*handle = LoadSoundMem2(wf1,wf2);
	}


	//音楽　Music関係系
	int PlayMusic_( char *FileName , int PlayType ){
		return PlayMusic( FileName , PlayType ) ;
	}
	int CheckMusic_( void ){
		return  CheckMusic( ) ;
	}
	int StopMusic_( void ){
		return StopMusic() ;
	}
	int SetVolumeMusic_( int Volume ){
		return SetVolumeMusic( Volume ) ;
	}
	//乱数系
	int GetRand_( int RandMax ){
		return GetRand( RandMax ) ;
	}
	int SRand_( int RandMax ){
		SRandNumber=RandMax;//The argument of Srand Function
		return SRand(  RandMax ) ;
	}
	//WindowMode
	int ChangeWindowMode_( int Flag ){
		return ChangeWindowModeResult=ChangeWindowMode(  Flag ) ;
	}
	//256ColorPalette系
	int SetPalette_( int PalIndex , int Red , int Green , int Blue ){
		return SetPalette( PalIndex ,  Red , Green , Blue ) ;
	}
	int ReflectionPalette_( void ){
		return ReflectionPalette() ;
	}
	int GetPalette_( int PalIndex ,int *Red , int *Green , int *Blue ){
		return  GetPalette(PalIndex ,Red ,Green , Blue ) ;
	}
	int SetBmpPal_( char *FileName ){
		return SetBmpPal(FileName ) ;
	}
	int SetBmpPalPart_( char *FileName , int StartNum ,int GetNum , int SetNum ){
		return SetBmpPalPart(FileName ,StartNum ,GetNum ,SetNum ) ;
	}
	//NetWork 通信系
	int ConnectNetWork_( IPDATA IPData ){
		return  ConnectNetWork( IPData ) ;
	}
	void ConnectNetWorkArgument(IPDATA IPData,int *Handle){
		*Handle = ConnectNetWork(IPData);
	}
	int CloseNetWork_( int NetHandle ){
		return  CloseNetWork(  NetHandle ) ;
	}
	int PreparationListenNetWork_( void ){
		return  PreparationListenNetWork( ) ;
	}
	int StopListenNetWork_( void ){
		return StopListenNetWork( ) ;
	}
	int NetWorkSend_( int NetHandle, void *Buffer, int Length ){
		return NetWorkSend( NetHandle,Buffer,Length ) ;
	}
	int GetNetWorkDataLength_( int NetHandle ){
		return GetNetWorkDataLength( NetHandle ) ;
	}
	void GetNetWorkDataLengthArgument(int NetHandle,int *GetData){
		*GetData = GetNetWorkDataLength(NetHandle);
	}
	int GetNetWorkSendDataLength_( int NetHandle ){
		return GetNetWorkSendDataLength( NetHandle ) ;
	}
	void GetNetWorkSendDataLengthArgument(int NetHandle,int *GetData){
		*GetData = GetNetWorkSendDataLength(NetHandle);
	}
	int NetWorkRecv_( int NetHandle, void *Buffer, int Length ){
		return NetWorkRecv(NetHandle, Buffer, Length ) ;
	}
	int NetWorkRecvToPeek_( int NetHandle, void *Buffer, int Length ){
		return NetWorkRecvToPeek(NetHandle,Buffer,Length ) ;
	}
	int GetNewAcceptNetWork_( void ){
		return  GetNewAcceptNetWork(  ) ;
	}
	void GetNewAcceptNetWorkArgument(int *GetData){
		*GetData = GetNewAcceptNetWork();
	}
	int GetLostNetWork_( void ){
		return  GetLostNetWork(  ) ;
	}
	void GetLostNetWorkArgument(int *GetData){
		*GetData = GetLostNetWork();
	}
	int GetNetWorkAcceptState_( int NetHandle ){
		return GetNetWorkAcceptState( NetHandle ) ;
	}
	int GetNetWorkIP_( int NetHandle , IPDATA *IpBuf ){
		return GetNetWorkIP(  NetHandle ,IpBuf ) ;
	}
	//ムービー映画Movie関係
	int PlayMovie_( char *FileName , int ExRate , 
					int PlayType /*
					DX_MOVIEPLAYTYPE_BCANCEL : ボタンキャンセルあり
　　　　　　　　　　DX_MOVIEPLAYTYPE_NORMAL　: ボタンキャンセルなし*/
	){
		return PlayMovie(FileName , ExRate , PlayType ) ;
	}
	int PlayMovieToGraph_( int GraphHandle ){
		return PlayMovieToGraph(  GraphHandle ) ;
	}
	int PauseMovieToGraph_( int GraphHandle ){
		return PauseMovieToGraph(GraphHandle ) ;
	}
	int SeekMovieToGraph_( int GraphHandle , int Time ){
		return SeekMovieToGraph( GraphHandle , Time ) ;
	}
	int GetMovieStateToGraph_( int GraphHandle ){
		return GetMovieStateToGraph( GraphHandle ) ;
	}
	//マイナー系
	int SetUse3DFlag_( int Flag ){
		if(FALSE==Flag)
			_3DFlag=false;//TRUEで3D使用中　SetUse3DFlag
		else
			_3DFlag=true;

		return SetUse3DFlag(  Flag ) ;
	}
	int SetUseVramFlag_( int Flag ){
		if(Flag==FALSE)
			NowSetUseVramFlag=false;
		else
			NowSetUseVramFlag=true;

		return SetUseVramFlag( Flag ) ;
	}
	int GraphLock_( int GrHandle ,int *PitchBuf , void **DataPointBuf ){
		return GraphLock( GrHandle ,PitchBuf , DataPointBuf ) ;
	}
	int GraphUnLock_( int GrHandle ){
		return GraphUnLock(GrHandle ) ;
	}
	int SetWaitVSyncFlag_( int Flag ){
		if(FALSE==Flag)
			VSyncFlag=false;//TRUEでCRT垂直同期信号を待つ
		else
			VSyncFlag=true;

		return SetWaitVSyncFlag(Flag ) ;
	}
	int GetColorBitDepth_( void ){
		return  GetColorBitDepth(  ) ;
	}
	void GetColorBitDepthArgument(int *CBD){
		*CBD = GetColorBitDepth();
	}
	int SetTransColor_( int Red , int Green , int Blue ){
		SetTransColor_Red=Red;
		SetTransColor_Green=Green;
		SetTransColor_Blue=Blue;
	
		return SetTransColor(Red , Green , Blue ) ;
	}
	int SetGraphColorBitDepth_( int ColorBitDepth ){
		NowGraphColorBitDepth=ColorBitDepth;//SetGraphColorBitDepth_( int ColorBitDepth ){
	
		return SetGraphColorBitDepth( ColorBitDepth ) ;
	}
	int SetUseGraphAlphaChannel_( int UseFlag ){
		SetUseGraphAlphaChannel_Flag=UseFlag;//SetUseGraphAlphaChannel(  UseFlag ) ;
		return  SetUseGraphAlphaChannel(  UseFlag ) ;
	}
	int SetGraphDataShavedMode_( int ShavedMode/* 
									DX_SHAVEDMODE_DITHER　　: ディザリングによる緩和
　　　　　　　　　　　　　　　　　　DX_SHAVEDMODE_DIFFUS　: 誤差拡散による緩和
　　　　　　　　　　　　　　　　　　DX_SHAVEDMODE_NONE　　: 画像劣化緩和処理を行わない
									*/
	){
		return SetGraphDataShavedMode(  ShavedMode ) ;
	}

	int SaveDrawScreen_( int x1, int y1, int x2, int y2, char *FileName ){
		return SaveDrawScreen( x1,y1, x2, y2, FileName ) ;
	}
	int LoadPauseGraph_( char *FileName ){
		static bool initflg=false;
		static int _LPGResult;
		if(FileName==NULL){
			 _LPGResult = LoadPauseGraph( NULL ) ;
			return _LPGResult;
		}

		if(false==initflg){
			PauseGraphName=(char *)malloc(strlen(FileName)+1);
			initflg=true;
		}else{
			free(PauseGraphName);
			PauseGraphName=(char *)malloc(strlen(FileName)+1);
		}
		strcpy(PauseGraphName, FileName);

		return LoadPauseGraph( FileName ) ;
	}
	int SetWindowText_( char *WindowText ){
		static bool initflg=false;

		if(WindowText==NULL){
			WindowText="DGC for DxLib";
		}
		if(false==initflg){
			SoftName=(char *)malloc(strlen(WindowText)+1);
			initflg=true;
		}else{
			free(SoftName);
			SoftName=(char *)malloc(strlen(WindowText)+1);
		}
		strcpy(SoftName,WindowText);
			
		return  SetWindowText( WindowText ) ;
	}
	int SetOutApplicationLogValidFlag_( int Flag ){
		if(FALSE==Flag)
			LogFlag=false;
		else
			LogFlag=true;

		return SetOutApplicationLogValidFlag( Flag ) ;
	}
	int SetBasicBlendFlag_( int Flag ){

	 if(FALSE==Flag)
		 BasicBlendFlag=false;
	 else
		 BasicBlendFlag=true;
	
		return SetBasicBlendFlag( Flag ) ;
	}
	int SetScreenMemToVramFlag_( int Flag ){
	
	if(FALSE==Flag)
		ScreenSystemMemory=false;
	else
		ScreenSystemMemory=true;//TRUEでシステムメモリに裏画面を置いている　SetScreenMemToVramFlag( SMemFlag )

		return  SetScreenMemToVramFlag(  Flag ) ;
	}
	int GetUse3DFlag_( void ){
		return GetUse3DFlag() ;
	}
	int ScreenCopy_( void ){
		return  ScreenCopy( ) ;
	}
	int EnumFontName_( char *NameBuffer , int NameBufferNum ){
		return EnumFontName(NameBuffer , NameBufferNum ) ;
	}





	//画面操作系
	int	ClsDrawScreen_( void ){
		return ClsDrawScreen();// 画面の状態を初期化する
	}
	//２D描画系
	int	DrawExtendGraph_( int x1 , int y1 , int x2 , int y2 , int GrHandle , int TransFlag ){
		return DrawExtendGraph( x1 , y1 , x2 , y2 , GrHandle ,TransFlag ) ;// グラフィックの拡大縮小描画
	}
	int	DrawRotaGraph_( int x, int y, double ExRate, double Angle, int GrHandle , int TransFlag , int TurnFlag = FALSE  ){
		return DrawRotaGraph( x, y, ExRate, Angle,GrHandle ,TransFlag ,TurnFlag  ) ;// グラフィックの回転描画
	}
	int	DrawRotaGraph2_( int x, int y, int cx, int cy, double ExtRate, double Angle , int GrHandle , int TransFlag , int TurnFlag = FALSE  ){
		return DrawRotaGraph2_( x, y, cx, cy, ExtRate, Angle ,GrHandle ,TransFlag , TurnFlag );// グラフィックの回転描画２
	}
	int	DrawModiGraph_(int x1, int y1, int x2, int y2, int x3, int y3, int x4, int y4, int GrHandle , int TransFlag ){
		return DrawModiGraph( x1, y1, x2, y2, x3, y3, x4, y4, GrHandle , TransFlag ) ;	// 画像の自由変形描画
	}

	int	DrawTurnGraph_( int x , int y , int GrHandle , int TransFlag ){
		return DrawTurnGraph( x, y ,GrHandle ,TransFlag ) ;	// 画像の左右反転描画
	}

	int DrawGraph_( int x, int y, int GrHandle, int TransFlag ){
		return DrawGraph( x, y, GrHandle, TransFlag ) ;
	}
	

	//3D描画系
//extern	int			DrawPrimitive( LPVERTEXDATA Vertex , int VertexNum , int DrawDataType , int GrHandle , int TransFlag ) ;				// ポリゴンを描画する
//extern	int			DrawPrimitive3D( LPVERTEXDATA_3D Vertex3D , int VertexNum , int DrawDataType , int GrHandle , int TransFlag ) ;				// ポリゴンを描画する
	


	//自分のエラー書き出しファイルを初期化する
	bool _MyInitLog( char *MyLogFileName )
	{
			FILE *fp;
			// エラーログファイルを開く
			if(NULL==(fp = fopen( MyLogFileName , "wt" ))){
				return false;
			}
			fclose( fp ) ;
		
		return true;
	}
	bool _MyAddLog( char *str,char *MyLogFileName ){
		FILE *fp;
		if(_debug==true){
			if(NULL != (fp = fopen( MyLogFileName , "at" ))){
				// エラーログファイルに書き出す
				fputs( str , fp ) ;
				fclose( fp ) ;
			}else{//もし、ふぁいるがなかったら
					_MyInitLog(MyLogFileName);
					_MyAddLog("ログファイルが無かったので初期化しなおしてます。\n",MyLogFileName);
					_MyAddLog("よって、途中のログが無い場合があります。\n",MyLogFileName);
					return false;
			}
		}
		return true;
	}
	void _MyDebugLogValidFlag(bool flg){
		_debug=flg;
	}
	
	bool _MyAddLogNum( char *str ,char *MyLogFileName, ... ){
		FILE *fp;
		char s[1024];
		va_list VaList ;
		va_start( VaList , str ) ;
		vsprintf( s , str , VaList ) ;
		va_end( VaList ) ;
		if(NULL != (fp = fopen( MyLogFileName , "at" ))){
			// エラーログファイルに書き出す
			fputs( s , fp ) ;
			fclose( fp ) ;
		}else{//もし、ふぁいるがなかったら
				_MyInitLog(MyLogFileName);
				_MyAddLog("ログファイルが無かったので初期化しなおしてます。\n",MyLogFileName);
				_MyAddLog("よって、途中のログが無い場合があります。\n",MyLogFileName);
				return false;
		}
		return true;
	}

	//FPS関係
	// １秒間経っていたらフレームレートを変更する
	void ___FPS_Begin(void){
		if( timeGetTime() - _FPS_Time >= 1000 )
		{
			// ＦＰＳの保存
			_FPS = _FPS_Count ;
			// フレームレートカウンタの初期化
			_FPS_Count = 0 ;

			// 現在のタイムカウントを保存
			_FPS_Time = timeGetTime() ;
		}
		_FPS_Count++;
	}

	void ___FPS_Draw(int x,int y,int Color,int EdgeColor=0){
		static char str[256];
		sprintf(str,"FPSは%d",_FPS);
		DrawString_(x,y,str,Color,EdgeColor);
	}



	bool _DrawMyPCState(bool LogFlag,int col,int MouseColor,int SleepTime,int KeyCode=KEY_INPUT_ESCAPE){ 
		//VideoMemory等を調べる
		LPDIRECTDRAW7 lpd;
		DDCAPS d;
		ZeroMemory(&d,sizeof(d));
		d.dwSize = sizeof(d);
		if(DirectDrawCreateEx(NULL,(void **)&lpd,IID_IDirectDraw7 ,NULL)!=DD_OK)
			return false;
			
		if(lpd->GetCaps(&d,NULL)!=DD_OK)
			return false;
		
		
		
		//変数
		static int OldFontSize;
		int MouseInput=0,plus=0;
		int XBuf=0,YBuf=0;//マウスの座標
		static char Softstr[512];//ソフト名
		static char PauseGraphNamestr[512];//否アクティブ時
		//ソフト名等格納
		strcpy(Softstr,"ソフト名：");
		strcat(Softstr,SoftName);

		strcpy(PauseGraphNamestr,"A background when not active:");
		if(PauseGraphName!=NULL)
			strcat(PauseGraphNamestr,PauseGraphName);
		else
			strcat(PauseGraphNamestr," NULL ");

		if(NowFontSize!=-1000)//フォントサイズ保存
			OldFontSize=NowFontSize;
		//ScreenSize格納
		static int _x,_y,_z;
			_GetScreenSize(&_x,&_y,&_z);

	#define _YNUM 22	
#define _DFS(y,str,data) DrawFormatString(10,_YNUM*y+plus,col,str,data) 
#define _DFSS(y,str) DrawString_(10,_YNUM*y+plus,str,col)

		if(-1==SetFontSize_(_YNUM)){//22Dotくらい
			return false;
		}
		/*ログを出力にセット
		if(LogFlag==true){
			SetOutApplicationLogValidFlag_(TRUE);
		}*/
		//bool LogFlag;//TRUEでログ出力中　SetOutApplicationLogValidFlag
			//3D機能は使う。
			
		//マウスフラグ
			bool leftf;
			bool rightf;
			bool middlef;
			//マウス移動量
			int Yordinate=0,YordinateRight=0;
			//文字列のY座標カウンタ
			int YCount;

		while( ProcessMessage() == 0 && CheckHitKey( KeyCode ) == 0 ){
			
			ClsDrawScreen();
			
			
			// 描画ブレンドモードをアルファブレンド（５０％）にする
			SetDrawBlendMode( DX_BLENDMODE_ALPHA , 128 ) ;

			DrawBox(10,0,640,480,GetColor(69,254,255),TRUE);
			SetDrawBlendMode(DX_BLENDMODE_NOBLEND,255);

			DrawCenterString_(plus+0,640,col,"Graphic State");
			_DFS(1,"画面領域X=%d",ScreenY);
			//DrawFormatString_(10,_YNUM*1,col,"画面領域X=%d",ScreenX);//SetGraphMode(SizeXValue;
			_DFS(2,"画面領域Y=%d",ScreenY);//SetGraphMode(SizeYValue;
			_DFS(3,"画面色数深度=%d",ColorBitDepth);//SetGraphMode(ColorBitNum;
			if(ScreenSystemMemory==false){//TRUEでシステムメモリに裏画面を置いている　SetScreenMemToVramFlag( SMemFlag )
				_DFSS(4,"裏画面はビデオメモリ");
			}else{
				_DFSS(4,"裏画面はシステムメモリ");
			}
			if(_3DFlag==false){
				_DFSS(5,"3D機能は使ってません");
			}else{
				_DFSS(5,"3D機能を使ってます");
			}
			if(FALSE == GetUse3DFlag_())//TRUEで3D使用中　SetUse3DFlag
					_DFSS(6,"3Dアクセラレータを使えません");
			else
				_DFSS(6,"3Dアクセラレータを使えます");



			if(NowSetUseVramFlag==true){
				_DFSS(7,"画像データはビデオメモリに置いてます");
			}else{
				_DFSS(7,"画像データはビデオメモリに置いてません");
			}

			if(VSyncFlag==true){//通常は待つよってTRUE　TRUEでCRT垂直同期信号を待つ
				_DFSS(8,"CRT垂直同期信号を待つ設定です。");
			}else{
				_DFSS(8,"CRT垂直同期信号を待たない設定です。");
			}
			if(BasicBlendFlag==false)//デフォルトはfalse　TRUEでブレンドモードの簡略化
				_DFSS(9,"アルファブレンディングは簡略化しません");
			else
				_DFSS(9,"アルファブレンディングは簡略化してます");

			switch(SetDrawModeType){
				case DX_DRAWMODE_NEAREST:
					_DFSS(10,"描画モードはネアレストネイバー法です");//DX_DRAWMODE_NEAREST　
					break;
				case DX_DRAWMODE_BILINEAR :
					_DFSS(10,"描画モードはバイリニア法です");
					break;
				default:
					_DFSS(10,"Error:不正な描画モードらしいです");
					break;
			}

			if(MouseDisplayFlag==false){//SetMouseDispFlag( MouseDispFlag ))// マウスの表示フラグのセット
				_DFSS(11,"マウスカーソルは表示してません");
				DrawFormatString_(400,_YNUM*11+plus,col,"Mouse=%d,%d",XBuf,YBuf);
			}
			else
			{
				_DFSS(11,"マウスカーソルを表示してます");
				DrawFormatString_(400,_YNUM*11+plus,col,"Mouse%d,%d",XBuf,YBuf);
			}
			switch(NowDrawScreen){
				case DX_SCREEN_FRONT://The State of The return value of SetDrawScreen;
					_DFSS(12,"表画面に描画してます");
					break;	
				case DX_SCREEN_BACK:
					_DFSS(12,"裏画面に描画してます");
					break;
				default:
					_DFSS(12,"Error:描画画面が分かりません");
					break;
			}
			if(NowUseMaskScreenFlag==false)//The State of Argument of SetUseMaskScreenFlag;
				_DFSS(13,"マスクの使用はしていません");
			else
				_DFSS(13,"マスクを使用してます");
			
			YCount=14;
			_DFSS(YCount,Softstr);
			YCount++;
			_DFSS(YCount,PauseGraphNamestr);
			YCount++;
			//memset(&SoftName,sizeof(char)*256);///SetWindowText
			//ZeroMemory(&PauseGraphName,sizeof(char)*256);//LoadPauseGraph( PaiseGraphName )

			DrawCenterString_(_YNUM*YCount+plus,640,col,"WindowsSystem");
			YCount++;
			___OSDraw(10,_YNUM*YCount+plus,col,_GetOSVersion());//OSを描画
			YCount++;
			if ((d.dwCaps & DDCAPS_3D) && (d.ddsCaps.dwCaps & DDSCAPS_TEXTURE)){
				 _DFSS(YCount,"ハードウェア3D支援、期待できます");
			}else{
				_DFSS(YCount,"ハードウェア3D支援、期待できません");
			}
			YCount++;

			
			
			DrawFormatString_(10,_YNUM*YCount+plus,col,"ScreenX=%d,ScreenY=%d,ScreenBitDepth=%d",_x,_y,_z);
			YCount++;
			_DFS(YCount,"グラフィックメモリ全容量=%d",d.dwVidMemTotal);
			YCount++;
			_DFS(YCount,"使用可能グラフィックメモリ=%d",d.dwVidMemFree);
			YCount++;
			//	(DriverCaps.ddsCaps.dwCaps & DDSCAPS_TEXTURE))
			___MemoryDraw(10,_YNUM*YCount+plus,col,_YNUM);//メモリを描画
			YCount++;
			//三角を描画
			DrawString(620,0,"△",col);
			DrawString(620,460,"▽",col);
			
			//マウス取得
			MouseInput = GetMouseInput();
			GetMousePoint( &XBuf, &YBuf );
			
			if( ( MouseInput & MOUSE_INPUT_LEFT ) == 0 ){
				if(leftf==true){
					//100 - 90 = 10
					//100 - 110 = -10

				Yordinate-=YBuf;
				plus+=Yordinate;
				}
				leftf=false;
			}else{
				if(leftf!=true){
					GetMousePoint(&XBuf,&Yordinate);
				}
				leftf=true;
				//判定
				if(XBuf<640 && XBuf >610 && YBuf<30 && YBuf>0)
					plus+=5;
				if(XBuf<640 && XBuf>613 && YBuf>450 && YBuf<480)
					plus-=5;
			}
			if( (MouseInput & MOUSE_INPUT_RIGHT) == 0 ){
				if(rightf==true){
					//100 - 90 = 10
					//100 - 110 = -10

				YordinateRight-=YBuf;
				plus-=YordinateRight;
				}
					rightf=false;
				
			}else{
				if(rightf!=true){
					GetMousePoint(&XBuf,&YordinateRight);
				}
				rightf=true;
				//あたり判定
				if(XBuf<640 && XBuf >610 && YBuf<30 && YBuf>0)
					plus-=5;
				if(XBuf<640 && XBuf>613 && YBuf>450 && YBuf<480)
					plus+=5;
			}
			if( (MouseInput & MOUSE_INPUT_MIDDLE) == 0 ){middlef=false;}
			else{
				middlef=true;
				plus=0;
			}
			
			
			//マウス描画
			DrawString(XBuf,YBuf,"↑Mouse",MouseColor);

			ScreenFlip();
				//SetDrawBlendMode_BlendType=DX_BLENDMODE_NOBLEND;//The state of the argument of SetBlendMode BlendMode
			//SetDrawBlendMode_Pal=-1000;//The State of the argument of SetBlendMode Pal
		
		}
		//フォントサイズを戻す
		lpd->Release();
		SetFontSize_(OldFontSize);
		return true;
	}




	void ___MemoryDraw(int x,int y,int color,int FontSize){
		

	  MEMORYSTATUS s;
	  s.dwLength=sizeof(MEMORYSTATUS);
	  GlobalMemoryStatus(&s);
		//　物理メモリの空き・全体 (良く分からないけど
		DrawFormatString(x,y+FontSize*0,color,"メモリ使用率=%d％", s.dwMemoryLoad);
		DrawFormatString(x,y+FontSize*1,color,"総物理メモリ量=%dMB", s.dwTotalPhys /1024 /1024); 
		DrawFormatString(x,y+FontSize*2,color,"利用可能物理メモリ量=%dKB" ,s.dwAvailPhys/1024); 
		DrawFormatString(x,y+FontSize*3,color, "総ページファイルサイズ=%d byte" ,s.dwTotalPageFile);
		DrawFormatString(x,y+FontSize*4,color, "利用可能ページファイルサイズ=%d byte" ,s.dwAvailPageFile);
		DrawFormatString(x,y+FontSize*5,color, "総仮想メモリサイズ=%dKB" ,s.dwTotalVirtual /1024);
		DrawFormatString(x,y+FontSize*6,color, "利用可能仮想メモリサイズ=%dKB", s.dwAvailVirtual /1024);


	}

	
	void DrawCenterString_(int y,int screenX,int color,char *c){
			DrawString(ScreenX / 2 - GetDrawStringWidth( c , strlen(c))/2,y,c,color);
		}
	void _AllVariableDraw(void){
		char str[1024];
		for(int i=0;i<10;i++)
		  DrawFormatString( 0 , 20 * i , GetColor(255,255,255) ,"VSyncFlag=%d" , VSyncFlag ) ;

		DrawFormatString_(0,20*(i+1),GetColor(255,255,255),"SoftName=%s",SoftName);
	}/*
	
			
		 SetTransColor_Red=-1000;//すべて未使用
		 SetTransColor_Green=-1000;
		 SetTransColor_Blue=-1000;
		 NowGraphColorBitDepth=-1000;//SetGraphColorBitDepth_( int ColorBitDepth ){
		 SetUseGraphAlphaChannel_Flag=-1000;//SetUseGraphAlphaChannel(  UseFlag ) ;
		 ChangeWindowModeResult=-1000;//ChangeWindowMode( WindowModeFlag )でどのような値が帰ったか？
		
		 

		 SetGraphModeResult=-1000;//SetGraphModeの戻り値保存
		 
		
		 SRandNumber=-1000;//The argument of Srand Function
		 
		
		 RedBright=255;//The State of the Argument RedBright of SetDrawBrigt
		 GreenBright=255;//The State of the Argument GreenBright of SetDrawBright
		 BlueBright=255;//The State of the Argument BlueBright of SetDrawBright
		 NowFontSize=-1000;//The State of Argument of SetFontSize
		 NowFontThickness=-1000;//The State of Argument of SetFontThickness;
		 NowDrawArea={0,0,ScreenX,ScreenY};//The State of Argument of SetDrawArea( int x1 , int y1 , int x2 , int y2 ){
		 
*/


	int _GetOSVersion(void){
		
		OSVERSIONINFO os;
		os.dwOSVersionInfoSize=sizeof(os);

		 
		if(GetVersionEx(&os)==0)
			return -1;
		

		if(os.dwMajorVersion<=3){
			//というかWindows3.1使う馬鹿いないし…また、
			//ここらへん間違っていそう…参考にはしないように
			if(os.dwMinorVersion==51){
				return enuWindowsNT3_51;
			}
			if(os.dwPlatformId==VER_PLATFORM_WIN32s)
				return enuWindows3_1;
		}

		switch(os.dwPlatformId){
			case VER_PLATFORM_WIN32s:
				return enuWindows3_1;
				
			case VER_PLATFORM_WIN32_WINDOWS:
				if(os.dwMajorVersion >=4){
					if(os.dwMinorVersion<10)
						return enuWindows95;
					if(os.dwMinorVersion<90)
						return enuWindows98;
					if(os.dwMinorVersion>=90)
						return enuWindowsMe;
					else
						return -2;
				}
				if(os.dwMajorVersion==5){//念のため
					if(os.dwMinorVersion==0)
						return enuWindows2000;
					if(os.dwMinorVersion>0)
						return enuWindowsXP;
					else
						return -2;
				}
					
			
			case VER_PLATFORM_WIN32_NT:
				if(os.dwMajorVersion==4)
					return enuWindowsNT4_0;
				
				if(os.dwMajorVersion==5){
					if(os.dwMinorVersion==0)
						return enuWindows2000;
					if(os.dwMinorVersion>0)
						return enuWindowsXP;
					else
						return -2;
				}
				return -2;
			default:
				return -2;
		}
		return -1;
	}
	void _GetScreenSize(int *x,int *y,int *BitDepth){
		HDC hdc = GetDC( NULL ) ;
		*BitDepth = GetDeviceCaps( hdc , PLANES ) * GetDeviceCaps( hdc , BITSPIXEL ) ;
		ReleaseDC( NULL , hdc ) ;
		*x = GetSystemMetrics( SM_CXSCREEN ) ;
		*y = GetSystemMetrics( SM_CYSCREEN ) ;
	}
	

	bool ___OSDraw(int x,int y,int color,int os){
		switch(os){
			case enuWindows3_1:
				DrawString(x,y,"Windows3.1",color);
				break;
			case enuWindowsNT3_51:
				DrawString(x,y,"WindowsNT3.51",color);
				break;
			case enuWindowsNT4_0:
				DrawString(x,y,"WindowsNT4.0",color);
				break;
			case enuWindows95:
				DrawString(x,y,"Windows95",color);
				break;
			case enuWindows98:
				DrawString(x,y,"Windows98",color);
				break;
			case enuWindows2000:
				DrawString(x,y,"Windows2000",color);
				break;
			case enuWindowsMe:
				DrawString(x,y,"WindowsMe",color);
				break;
			case enuWindowsXP:
				DrawString(x,y,"WindowsXP",color);
				break;
			default:
				DrawString(x,y,"Error",color);
				return false;
		}
		return true;
	}





	//エラーログなど
	BOOL ErrorLogAdd_( char *ErrorStr ){			// エラー文書を書き出す
		return ErrorLogAdd( ErrorStr ) ;
	}
	int	AddLog( char *String ){	// ログ出力(奨励しません
		return AddLog( String ) ;
	}
	//BOOL ErrorLogFmtAdd( char *FormatString , ... ) ;	// 書式付きエラー文書を書き出す

	int ProcessMessage_( void ){
		return ProcessMessage( ) ;
	}


};


class __BOTSU{
public:
	__BOTSU(){}
	~__BOTSU(){}
	bool ___DrawMyOS(int x,int y,int FontSize){
		OSVERSIONINFO os;
		os.dwOSVersionInfoSize=sizeof(os);

		 
		if(GetVersionEx(&os)==0)
			return false;

		DrawFormatString( x ,y*FontSize , GetColor(255,255,255) ,"os.dwBuildNumber=%d" , os.dwBuildNumber );
		DrawFormatString(x,(y+1)*FontSize,GetColor(255,255,255),"os.dwMajorVersion=%d",os.dwMajorVersion);
		DrawFormatString(x,(y+2)*FontSize,GetColor(255,255,255),"os.dwMinorVersion=%d",os.dwMinorVersion);
		DrawFormatString(x,(y+3)*FontSize,GetColor(255,255,255),"os.szCSDVVersion=%d or %s",os.szCSDVersion,os.szCSDVersion);
		return true;
	}
};