//------------------------------------------------------------------------
//VixarLibrary.h
//------------------------------------------------------------------------

#pragma once

#include <windows.h>
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <float.h>
#include <sys/timeb.h>
#include <time.h>

#include <d3d9.h>
#include <d3dx9.h>
#include <dinput.h>
#include <dmusici.h>
#include <dsound.h>

#include <vector>
#include <string>
#include <sstream>

using namespace std;

#pragma	comment(lib, "d3d9.lib")
#pragma	comment(lib, "d3dx9.lib")
#pragma comment(lib, "dinput8.lib")
#pragma comment(lib, "dxguid.lib")
#pragma comment(lib, "dsound.lib")
#pragma comment(lib, "winmm.lib")
#pragma comment(lib, "odbc32.lib")
#pragma comment(lib, "odbccp32.lib")
#ifdef NDEBUG
#pragma comment(lib, "VixarLibrary.lib")
#else
#pragma comment(lib, "VixarLibraryD.lib")
#endif

//マクロで解放処理
#define SAFE_RELEASE(x){ if(x != NULL){ x->Release(); x=NULL; } }
//マクロで解放処理
#define SAFE_DELETE(p) { if(p != NULL){ delete (p); (p)=NULL; } }
//マクロで解放処理
#define SAFE_DELETE_ARRAY(p) { if(p != NULL) { delete[] (p);   (p)=NULL; } }

//ミュージックファイルの最大数
#define MUSIC_MAX 8
//サウンドファイルの最大数
#define SOUND_MAX 16

//現在のディレクトリを取得
char* GetDirectory(void);
//四捨五入
int	round(float value);
//eyeから見たatの方向をラジアンで取得
float GetDirRadian(D3DXVECTOR3 eye, D3DXVECTOR3 at);
//eyeから見たatの方向をディグリー(度)で取得
float GetDirDegree(D3DXVECTOR3 eye, D3DXVECTOR3 at);
D3DXMATRIX GetPosture(D3DXVECTOR3* vecUpper,D3DXVECTOR3* vecFront);

//------------------------------------------------------------------------
//マテリアルクラス
//------------------------------------------------------------------------
class CMaterial
{
public:
	//コンストラクタ
	CMaterial();
	//デストラクタ
	~CMaterial();

private:
	//マテリアル名
	std::string m_name;
	//赤・緑・青・アルファ
	float m_r, m_g, m_b, m_a;
	//Shader
	int m_shader;
	//拡散光
	float m_diffuse;
	//周囲光
	float m_ambient;
	//自己照明
	float m_emissive;
	//反射光
	float m_specular;
	//反射の強さ
	float m_power;
	//テクスチャ名
	std::string m_texture_name;
	//アルファテクスチャ名
	std::string m_alpha_name;
	//バンプテクスチャ名
	std::string m_bump_name;
	//マテリアルオブジェクト
	D3DMATERIAL9 m_material;
	//テクスチャオブジェクト
	LPDIRECT3DTEXTURE9 m_texture;

public:
	//マテリアル名セット
	void SetName(std::string name);
	//マテリアル名取得
	std::string GetName();
	//赤・緑・青・アルファセット
	void SetRGBA(float r,float g,float b,float a);
	//赤取得
	float GetR() const;
	//緑取得
	float GetG() const;
	//青取得
	float GetB() const;
	//アルファ取得
	float GetA() const;
	//Shaderセット
	void SetShader(int shader);
	//Shader取得
	int GetShader();
	//拡散光セット
	void SetDiffuse(float diffuse);
	//拡散光取得
	float GetDiffuse();
	//周囲光セット
	void SetAmbient(float ambient);
	//周囲光取得
	float GetAmbient();
	//自己照明セット
	void SetEmissive(float emissive);
	//自己照明取得
	float GetEmissive();
	//反射光セット
	void SetSpecular(float specular);
	//反射光取得
	float GetSpecular();
	//反射の強さセット
	void SetPower(float power);
	//反射の強さ取得
	float GetPower();
	//テクスチャ名セット
	void SetTextureName(std::string texture_name);
	//テクスチャ名取得
	std::string GetTextureName();
	//アルファテクスチャ名セット
	void SetAlphaName(std::string alpha_name);
	//アルファテクスチャ名取得
	std::string GetAlphaName();
	//バンプテクスチャ名セット
	void SetBumpName(std::string bump_name);
	//バンプテクスチャ名取得
	std::string GetBumpName();
	//マテリアルオブジェクト取得
	D3DMATERIAL9 *GetMaterial();
	//テクスチャオブジェクト取得
	LPDIRECT3DTEXTURE9 GetTexture();
	//マテリアルセット
	void SetMaterial();
	//テクスチャファイル読み込み
	void LoadTexture(LPDIRECT3DDEVICE9 dev);
	//テクスチャの解放
	void ReleaseTexture();

public:
	//演算子のオーバーロード
	CMaterial& operator=(const CMaterial& pt);
	//演算子のオーバーロード
	CMaterial (const CMaterial& pt);
};

//------------------------------------------------------------------------
//頂点情報
//------------------------------------------------------------------------
struct NVERTEX
{
	//頂点座標
	float x,y,z;
	//法線
	float nx,ny,nz;
	//UV値
	float tu,tv;
};
//頂点
#define	FVF_NVERTEX (D3DFVF_XYZ | D3DFVF_NORMAL | D3DFVF_TEX1)
//頂点をセットする
void SetNVertex(NVERTEX *v,const D3DXVECTOR3& pos,const D3DXVECTOR3& normal,float tu,float tv);

//------------------------------------------------------------------------
//頂点情報2
//------------------------------------------------------------------------
struct UVVERTEX
{
	//頂点座標
	float x,y,z;
	//UV値
	float tu,tv;
};
//頂点
#define	FVF_UVVERTEX (D3DFVF_XYZ | D3DFVF_TEX1)
//頂点をセットする
void SetUVVertex(UVVERTEX *v,const D3DXVECTOR3& pos,float tu,float tv);

//------------------------------------------------------------------------
//ベクトルクラス	
//------------------------------------------------------------------------
class CVector : public D3DXVECTOR3
{
public:
	CVector();
	CVector(float x2, float y2, float z2);

private :
	//ボーン影響頂点
	int m_selectedNumber;

public:
	void SetSelectedNumber(int b) { m_selectedNumber = b; }
	int GetSelectedNumber() { return m_selectedNumber; }

public:
	//演算子のオーバーロード
	CVector& operator=(const CVector& pt);
	//演算子のオーバーロード
	CVector (const CVector& pt);
};

//------------------------------------------------------------------------
//頂点クラス	
//------------------------------------------------------------------------
class CVertex
{
public:
	//コンストラクタ
	CVertex();
	CVertex (float x, float y, float z);

private:
	//位置座標
	D3DXVECTOR3 m_pos;
	//法線
	D3DXVECTOR3 m_normal;
	//頂点を共有する面配列
	vector < UINT > m_have_faces;

public:
	//位置セット
	void SetPos(D3DXVECTOR3 v);
	//位置取得
	D3DXVECTOR3 GetPos() const;
	//法線セット
	void SetNormal(D3DXVECTOR3 v);
	//法線取得
	D3DXVECTOR3 GetNormal();
	//頂点を共有する面を配列に追加
	void PushBackHaveFaces(int f);
	//頂点を共有する面を配列のサイズ取得
	int GetHaveFacesSize();
	//頂点を共有する面を配列の取得
	int GetHaveFaces(int f);
	//法線の正規化
	void Normalize();
	//法線を加算
	void AddNormal(D3DXVECTOR3 v);

public:
	//演算子のオーバーロード
	CVertex& operator=(const CVertex& pt);
	//演算子のオーバーロード
	CVertex(const CVertex& pt);
};

//------------------------------------------------------------------------
//UV座標クラス
//------------------------------------------------------------------------
class CUV
{
public:
	//コンストラクタ
	CUV();
	//コンストラクタ
	CUV(float u,float v);
	//デストラクタ
	~CUV();

public:
	//UV座標
	float m_u,m_v;

public:
	//演算子のオーバーロード
	CUV& operator=(const CUV& pt);
	//演算子のオーバーロード
	CUV (const CUV& pt);
};

//------------------------------------------------------------------------
//面クラス
//------------------------------------------------------------------------
class CFace
{
public:
	//コンストラクタ
	CFace();
	//デストラクタ
	~CFace();

private:
	//マテリアル番号
	int m_material;
	//面の法線
	D3DXVECTOR3 m_normal;
	//頂点インデックス
	vector < UINT > m_index;
	//UV座標
	vector < CUV > m_uv;
	//頂点ごとの法線
	vector < CVertex > m_vertex;

public:
	//マテリアル番号セット
	void SetMaterial(int material);
	//マテリアル番号取得
	int GetMaterial() const;
	//頂点インデックス追加
	void PushBackIndex(int i);
	//頂点インデックスサイズ取得
	int GetIndexSize() const;
	//頂点インデックス取得
	UINT GetIndex(UINT i);
	//U座標取得
	float GetU(UINT i);
	//V座標取得
	float GetV(UINT i);
	//UV座標配列サイズ取得
	int GetUVSize();
	//UV座標配列に追加
	void PushBackUV(const CUV& i);
	//法線セット
	void SetNormal(D3DXVECTOR3 normal);
	//法線取得
	D3DXVECTOR3 GetNormal() const;
	//法線の正規化
	void Normalize();
	//外積
	void CrossProduct(const D3DXVECTOR3& a,const D3DXVECTOR3& b);
	//頂点追加
	void PushBackVertex(CVertex v);
	//頂点サイズ変更
	void ResizeVertex(int i);
	//頂点サイズ取得
	int GetVertexSize();
	//頂点法線セット
	void SetVNormal(int i,D3DXVECTOR3 v);
	//頂点法線追加
	void AddVNormal(int i,D3DXVECTOR3 v);
	//頂点法線取得
	D3DXVECTOR3 GetVNormal(int i);
	//頂点面追加
	void PushBackHaveFaces(int i,int f);
	//頂点面サイズ取得
	int GetHaveFacesSize(int i);
	//頂点面取得
	int GetHaveFaces(int i,int f);
	//頂点法線正規化
	void VNormalize(int i);

public:
	//演算子のオーバーロード
	CFace& operator=(const CFace& pt);
	//演算子のオーバーロード
	CFace (const CFace& pt);
};

//------------------------------------------------------------------------
//モデルクラス
//------------------------------------------------------------------------
class CModel
{
public:
	//コンストラクタ
	CModel();
	//デストラクタ
	~CModel();

private:
	//モデル名
	std::string m_name;
	//頂点バッファ
	LPDIRECT3DVERTEXBUFFER9 m_vb;
	//鏡面
	int m_mirror_axis;
	//スムージング角度
	float m_facet;
	//頂点配列
	vector < CVector > m_vertices;
	//ボーン変形後の頂点配列
	vector < UVVERTEX > m_vertices2;
	//変形後の頂点配列
	vector < D3DXVECTOR3 > m_transVertices;
	//インデックス
	vector < int > m_indices;
	//面配列
	vector < CFace > m_faces;
	//面のグループ
	vector < int > m_groups;
	//アニメーション
	vector < vector<D3DXMATRIX> > m_animations;
	//トランスフォーム
	D3DXMATRIX m_transform;
	//ボーン
	vector < vector< vector<D3DXMATRIX> > > m_bones;
	//ボーンアニメーション名
	vector < std::string > m_boneAnimationName;

public:
	//面インデックスの取得
	int GetFaceIndex(int i,int j);
	//頂点座標の取得
	D3DXVECTOR3 GetVertexPos(int i);
	//モデル名のセット
	void SetName(std::string name);
	//モデル名取得
	std::string GetName();
	//鏡面セット
	void SetMirrorAxis(int mirror_axis);
	//鏡面取得
	int GetMirrorAxis();
	//スムージング角度セット
	void SetFacet(float facet);
	//スムージング角度取得
	float GetFacet();
	//頂点配列に追加
	void PushBackVector(CVector v);
	//面配列に追加
	void PushBackFace(const CFace& f);
	//頂点配列のサイズを取得
	int GetVerticesSize();
	//面配列のサイズを取得
	int GetFacesSize();
	//面の法線を計算
	void CalcFlatFaceNormal();
	//頂点の法線を計算
	void CalcFaceVertexNormal();
	//頂点がある面を計算
	void FacesVertexBelongsTo();
	//アニメーション配列に追加
	void PushBackAnimation();
	//アニメーション配列に追加2
	void PushBackAnimation(int i,const D3DXMATRIX& m);
	//ボーン配列に追加
	void PushBackBoneAnimation(int name);
	//ボーン配列に追加2
	void PushBackBone(int i,int j,const D3DXMATRIX& m);
	//ボーンアニメーション配列のサイズを取得
	int GetBoneAnimationNameSize();
	//ボーンアニメーション配列のサイズを取得
	const char* GetBoneAnimationName(int name);
	//ボーンアニメーション配列のサイズを取得
	int GetBoneAnimationSize(int name);
	//ボーンアニメーション配列のサイズを取得
	int GetBoneSize(int name,int bone);
	//ボーンを取得
	D3DXMATRIX GetBone(int name,int bone,int anim);
	//ボーン名設定
	void PushBackBoneAnimationName(std::string name);
	//アニメーションを取得
	D3DXMATRIX GetAnimation(int i,int j);
	//アニメーション配列のサイズを取得
	int GetAnimationSize();
	//アニメーション配列のサイズを取得2
	int GetAnimationSize(int i);
	//当たり判定
	bool Collision(D3DXVECTOR3 pos,D3DXVECTOR3 dir,float* distance=NULL,D3DXVECTOR3* normal=NULL);
	//マウスとの当たり判定
	int MousePick(int x,int y,LPDIRECT3DDEVICE9 dev,D3DXVECTOR3* pos=NULL,float* dist=NULL);
	//プリミティブの描画
	void DrawPrimitive(LPDIRECT3DDEVICE9 dev,D3DXMATRIX *matWorld,std::vector<CMaterial> &materials);
	//プリミティブの描画2
	void DrawPrimitiveUP(LPDIRECT3DDEVICE9 dev,D3DXMATRIX *transform,std::vector<CMaterial> &materials,int name,int anim);
	//頂点バッファの作成
	void CreateVertexBuffer(LPDIRECT3DDEVICE9 dev,std::vector<CMaterial> &materials);
	//頂点バッファの解放
	void ReleaseVB();
	//頂点の作成
	void SetVertices();
	//頂点の作成
	void SetVertices2(LPDIRECT3DDEVICE9 dev,int name,int anim);

public:
	//演算子のオーバーロード
	CModel& operator=(const CModel& pt);
	//演算子のオーバーロード
	CModel (const CModel& pt);
};

//------------------------------------------------------------------------
//キャラクタークラス
//------------------------------------------------------------------------
class CCharacter
{
public:
	//コンストラクタ
	CCharacter();
	CCharacter(std::string name,const CCharacter& pt);
	//コンストラクタ
	CCharacter(std::string s);
	//デストラクタ
	~CCharacter();

private:
	//モデル配列
	vector < CModel > m_models;
	//当たり判定用モデル
	int m_collision_model;
	//マテリアル配列
	vector < CMaterial > m_materials;
	//アニメーション名配列
	vector < std::string > m_animation_names;
	//トランスフォーム
	D3DXMATRIX m_transform;
	//移動量(位置座標ではない)
	D3DXVECTOR3 m_move;
	//回転
	D3DXVECTOR3 m_rotate;
	//スケール
	D3DXVECTOR3 m_scale;
	//アニメーション
	float m_animation;
	//現在のアニメーション
	int m_current_animation;
	//アニメーションループフラグ
	bool m_animation_loop;
	//アニメーション最後で停止(true)、最初に戻る(false)
	bool m_animation_last;
	//アニメーション再生中か？
	bool m_animation_playing;

public:
	//アニメーション名取得
	const char* GetAnimationName(int i);
	//アニメーション名追加
	void PushBackAnimationName(std::string s);
	//アニメーション再生
	void PlayAnimation(int current,bool loop = true,bool last = false);
	//アニメーション停止
	void StopAnimation();
	//アニメーションが再生中か取得
	bool GetAnimationPlaying();
	//アニメーションが最後で停止するか取得
	bool GetAnimationLast();
	//現在のアニメーションを取得
	int GetCurrentAnimation();
	//アニメーションを取得
	float GetAnimation();
	//トランスフォームセット
	void SetTransform(D3DXMATRIX m);
	//トランスフォーム取得
	D3DXMATRIX GetTransform();
	//トランスフォームから現在位置取得
	D3DXVECTOR3 GetPosition();
	//モデル配列の最初
	vector<CModel>::iterator GetModelsBegin();
	//モデル配列の終わり取得
	vector<CModel>::iterator GetModelsEnd();
	//モデル配列のサイズ取得
	int GetModelsSize();
	//モデル配列のサイズ変更
	void ResizeModels(int i);
	//モデル配列の最後取得
	CModel* GetModelsBack();
	//モデル取得
	CModel* GetModel(int i);
	//モデルのポインタ取得
	CModel GetModel2(int i);
	//モデル配列に追加
	void PushBackModel(CModel m);
	//モデル名取得
	std::string GetModelName(int i);
	//当たり判定モデルを探す
	void SearchCollisionModel();
	//当たり判定
	bool Collision(D3DXVECTOR3 pos,D3DXVECTOR3 dir,float* distance=NULL,D3DXVECTOR3* normal=NULL);
	//マウスとの当たり判定
	bool MousePick(int x,int y,LPDIRECT3DDEVICE9 dev,D3DXVECTOR3* pos=NULL,float* dist=NULL);
	//トランスフォームと描画
	void TransformAndDrawModels(LPDIRECT3DDEVICE9 dev);
	//頂点バッファ作成
	void CreateVertexBuffer(LPDIRECT3DDEVICE9 dev);
	//移動セット
	void SetMove(float x,float y,float z);
	//移動セット
	void SetMove(D3DXVECTOR3 pos);
	//移動加算
	void AddMove(float x,float y,float z);
	//移動乗算
	D3DXVECTOR3 MultiplyMove(float x,float y,float z);
	//移動取得
	D3DXVECTOR3 GetMove();
	//X移動取得
	float GetMoveX();
	//Y移動取得
	float GetMoveY();
	//Z移動取得
	float GetMoveZ();
	//回転セット
	void SetRotate(float x,float y,float z);
	//回転セット
	void SetRotateY(float y);
	//回転加算
	void AddRotate(float x,float y,float z);
	//回転加算
	void AddRotateY(float y);
	//回転取得
	D3DXVECTOR3 GetRotate();
	//X回転取得
	float GetRotateX();
	//Y回転取得
	float GetRotateY();
	//Z回転取得
	float GetRotateZ();
	//スケールセット
	void SetScale(float x,float y,float z);
	//スケール加算
	void AddScale(float x,float y,float z);
	//スケール取得
	D3DXVECTOR3 GetScale();
	//マテリアル配列に追加
	void PushBackMaterial(const CMaterial& mat);
	//マテリアルセット
	void SetMaterials(std::vector<CMaterial> &mat);
	//マテリアル配列サイズ取得
	int GetMaterialSize();
	//マテリアルポインタ取得
	CMaterial* GetMaterial(int i);
	//テクスチャ読み込み
	void LoadTexture(LPDIRECT3DDEVICE9 dev);
	// MQAファイルの読み込み
	bool LoadMQAFile(std::string file_name,LPDIRECT3DDEVICE9 dev);
	//キャラクターのコピー
	void Copy(CCharacter* pt);
	// 3D座標を2D座標にトランスフォームします。
	POINT GetScreenPosition(LPDIRECT3DDEVICE9 dev);
	//演算子のオーバーロード
	CCharacter operator=(CCharacter& pt);
};

//------------------------------------------------------------------------
//CDirectXGraphicsクラス
//------------------------------------------------------------------------
class CDirectXGraphics
{
public:
	//コンストラクタ
	CDirectXGraphics();
	//コンストラクタ
	CDirectXGraphics(HWND hWnd,bool window,int width,int height);
	//デストラクタ
	~CDirectXGraphics();

private:
	//背景色
	D3DCOLOR m_bgColor;
	//アダプター
	int   m_adapter;
	//画面幅
	float m_width;
	//画面高さ
	float m_height;
	//Direct3D
	LPDIRECT3D9 m_pD3D;
	//Direct3Dデバイス
	LPDIRECT3DDEVICE9 m_pD3DDevice;
	//Direct3Dパラメーター
	D3DPRESENT_PARAMETERS m_d3dpp;
	//ライト
	D3DLIGHT9 m_light;
	//スプライトポインタ
	LPD3DXSPRITE m_pSprite;	

public:
	//Direct3Dデバイスの取得
	LPDIRECT3DDEVICE9 GetD3DDevice();
	//背景色セット
	void SetBgColor(int r,int g,int b);
	//画面サイズ変更
	void OnSize(int cx, int cy);
	//レンダリング開始
	void BeginRendering(float nearZ=100.0f,float farZ=10000.0f,float fov=10.0f);
	//カメラセット
	void SetCamera(D3DXVECTOR3 eye,D3DXVECTOR3 at);
	//カメラセット2
	D3DXMATRIX SetCamera2(D3DXVECTOR3 pos,D3DXVECTOR3 angle,D3DXVECTOR3 center);
	//ライトセット
	void SetLight(D3DXVECTOR3 dir);
	//レンダリング終了
	void EndRendering();
	//Zバッファをクリア
	void ClearZBuffer();
	//スプライト作成
	BOOL CreateSprite();
	//スプライト開始
	void BeginSprite();
	//スプライト終了
	void EndSprite();
	//スプライト取得
	LPD3DXSPRITE GetSprite();
	//フォント作成
	BOOL CreateFont(LPD3DXFONT *ppFont,int w,int h,bool bold,std::string font);
	//フォント描画
	void DrawText(ID3DXFont* pFont,std::string text,int left,int top,int right,int bottom,DWORD format,D3DCOLOR color);
};

//------------------------------------------------------------------------
//スプライトクラス
//------------------------------------------------------------------------
class CSprite
{
public:
	//コンストラクタ
	CSprite(void);
	//コンストラクタ
	CSprite(HWND hWnd,LPDIRECT3DDEVICE9 dev,char* fileName,int width,int height,bool alpha);
	//デストラクタ
	~CSprite(void);

private:
	//テクスチャオブジェクト
	LPDIRECT3DTEXTURE9 m_pImage;
	//位置座標
	D3DXVECTOR3		   m_position;

public:
	//イメージの読み込み
	void CreateImage(HWND hWnd,LPDIRECT3DDEVICE9 dev,char* fileName,int width,int height,bool alpha);
	//イメージ描画
	void Draw(LPD3DXSPRITE sprite,int left,int top,int right,int bottom);
	//位置セット
	void SetPosition(float x,float y,float z);
};

//------------------------------------------------------------------------
//CDirectInputクラス
//------------------------------------------------------------------------

#define FREE_KEY 0//キーが押されていない状態
#define PUSH_KEY 1//キーが押された瞬間
#define PULL_KEY 2//キーが放された瞬間
#define HOLD_KEY 3//キーが押されている状態

class CDirectInput
{
public:
	//コンストラクタ
	CDirectInput(void);
	//デストラクタ
	~CDirectInput(void);

private:
	//DirectInput
	LPDIRECTINPUT8			m_pDirectInput;         
	//DirectInputデバイス
	LPDIRECTINPUTDEVICE8	m_pKeyboard;

public:
	//DirectInput作成
	HRESULT CreateDirectInput(HWND hWnd);
	//キーボード状態取得
	bool GetKeyboardInput(int key,int& flag);
	//アクセス権のセット
	void SetAcquire(bool b);
};

//------------------------------------------------------------------------
//音楽ファイルを読み込んで再生するクラス
//------------------------------------------------------------------------
class CDirectMusic
{
public:
	//コンストラクタ
	CDirectMusic();
	//デストラクタ
	~CDirectMusic();

private:
	//DirectMusicローダー
	IDirectMusicLoader8*		m_pLoader;
	//DirectMusicパフォーマンス
	IDirectMusicPerformance8*	m_pPerformance;
	//DirectMusicセグメント
	IDirectMusicSegment8*		m_pSegment[MUSIC_MAX];

public:
	//メモリの解放
	VOID DeleteObj();			
	//初期化
	HRESULT Init();	
	//ファイルロード
	bool fileLoad(int sound,char* fileName);
	//再生
	HRESULT Play(int sound,BOOL bRepeats);
	//再生中か？
	HRESULT IsPlaying(int sound);
	//停止
	HRESULT Stop(int sound);
};

//------------------------------------------------------------------------
//WAVサウンド再生クラス
//------------------------------------------------------------------------
class CDirectSound
{
private:
	// DirectSound8
	LPDIRECTSOUND8		m_lpDS;	
	// プライマリサウンドバッファ
	LPDIRECTSOUNDBUFFER	m_lpPrimary;
	// セカンダリサウンドバッファ
	LPDIRECTSOUNDBUFFER	m_lpSecondary[SOUND_MAX];

public:
	//コンストラクタ
	CDirectSound();
	//デストラクタ
	~CDirectSound();
	//初期化
	BOOL Init(HWND hWnd);
	//プライマリサウンドバッファ作成
	BOOL CreatePrimaryBuffer(void);
	//WAVファイル読み込み
	BOOL LoadSound(int sound,char *fileName);
	//解放
	BOOL Release(void);
	//再生
	void Play(int sound,BOOL loop=false);
	//停止
	void Stop(int sound);
	//再生位置指定
	void SetCurrentPosition(int sound,int pos);
};

bool GetMouseState(int mouse,int& flag);
