#pragma once

////////////////////////////////////////////////////////////////////////////////////////////////////
// 名前空間
////////////////////////////////////////////////////////////////////////////////////////////////////

namespace Mix{ namespace Tool{ namespace Win32{ namespace Graphics{

	class Material;
	class VertexLayout;
	class VertexShader;
	class PixelShader;
	class VertexBuffer;
	class IndexBuffer;

	//定数
	enum VALUE
	{
		MAX_VERTEX_WEIGHT = 4,	//頂点の最大ウェイト数

		MAX_NAME_SIZE = 32,		//名前の最大文字数( NULL含める )
	};

	//名前の最大文字数( NULLを含めない )
	const unsigned int _MAX_NAME_SIZE = ( MAX_NAME_SIZE - 1 );

	//バーテックスエレメントセマンティクス列挙定数
	enum VERTEX_ELEMENT_SEMANTIC
	{
		VES_POSITION		= 0,
		VES_BLENDWEIGHT		= 1,
		VES_BLENDINDICES	= 2,
		VES_NORMAL			= 3,
		VES_PSIZE			= 4,
		VES_TEXTURE			= 5,
		VES_TANGENT			= 6,
		VES_BINORMAL		= 7,
		VES_COLOR			= 8,
	};

	//バーテックスエレメントセマンティクス最大数
	static const unsigned int VERTEX_ELEMENT_SEMANTIC_MAX = 9;

	//バーテックスレイアウトフォーマット列挙定数
	enum VERTEX_ELEMENT_FORMAT
	{
		VEF_FLOAT32_1	= 0,
		VEF_FLOAT32_2	= 1,
		VEF_FLOAT32_3	= 2,
		VEF_FLOAT32_4	= 3,
		VEF_UINT8_4		= 4,
		VEF_INT16_2		= 5,
		VEF_INT16_4		= 6,
		VEF_UINT8_4N	= 7,
		VEF_INT16_2N	= 8,
		VEF_INT16_4N	= 9,
		VEF_UINT16_2N	= 10,
		VEF_UINT16_4N	= 11,
		VEF_FLOAT16_2	= 12,
		VEF_FLOAT16_4	= 13,
	};

	//バーテックスエレメントフォーマット最大数
	static const unsigned int VERTEX_ELEMENT_FORMAT_MAX = 14;

	//バーテックスエレメント構造体
	struct VERTEX_ELEMENT
	{
		unsigned int semanticType;
		unsigned int semanticIndex;
		unsigned int format;
		unsigned int offset;

		VERTEX_ELEMENT( void )
		{
			semanticType = 0;
			semanticIndex = 0;
			format = 0;
			offset = 0;
		}

		VERTEX_ELEMENT( unsigned int st, unsigned int si, unsigned int f, unsigned int o )
		{
			semanticType = st;
			semanticIndex = si;
			format = f;
			offset = o;
		}
	};

	//ブレンドモード列挙定数
	enum BLEND_MODE
	{
		BLEND_COPY		= 0,	//コピー
		BLEND_NORMAL	= 1,	//通常
		BLEND_ADD		= 2,	//加算
		BLEND_SUB		= 3,	//減算
		BLEND_MUL		= 4,	//乗算
		BLEND_SCREEN	= 5,	//スクリーン
	};

	//テクスチャステージ最大数
	static const unsigned int TEXTURE_STAGE_MAX = 8;

	//シェーダーモデル列挙定数
	enum SHADER_MODEL
	{
		SHADER_MODEL_3 = 0x00000001,
		SHADER_MODEL_4 = 0x00000002,
		SHADER_MODEL_5 = 0x00000004,
	};

	//シェーダープロセスフラグ列挙定数
	enum SHADER_PROCESS_FLAG
	{
		SHADER_PROCESS_FOG			= 0x00000001,
		SHADER_PROCESS_SHADOW		= 0x00000002,
		SHADER_PROCESS_REFRACT		= 0x00000004,
//		SHADER_PROCESS_SOFTPARTICLE	= 0x00000008,
//		SHADER_PROCESS_BLOOM		= 0x00000010,
//		SHADER_PROCESS_DOF			= 0x00000020,
		SHADER_PROCESS_ATMOSPHERE	= 0x00000040,
//		SHADER_PROCESS_LUMINANCE	= 0x00000080,
		SHADER_PROCESS_SSAO			= 0x00000100,
	};

	//シェーダータイプ
	enum SHADER_TYPE
	{
		SHADER_NORMAL			= 0,	//通常
		SHADER_WATER			= 1,	//ウォーター
		SHADER_SHADELESS		= 2,	//ライティング無し
	};

	//ディフューズタイプ
	enum DIFFUSE_TYPE
	{
		DIFFUSE_LAMBERT			= 0,	//ランバート
		DIFFUSE_HALF_LAMBERT	= 1,	//ハーフランバート
	};

	//スペキュラータイプ
	enum SPECULAR_TYPE
	{
		SPECULAR_NONE			= 0,	//無し
		SPECULAR_PHONG			= 1,	//フォン
		SPECULAR_BLINN_PHONG	= 2,	//ブリンフォン
		SPECULAR_COOK_TORRANCE	= 3,	//クックトランス
	};

	//リフレクトタイプ
	enum REFLECT_TYPE
	{
		REFLECT_NONE	= 0,	//無し
		REFLECT_NORMAL	= 1,	//通常
		REFLECT_FRESNEL	= 2,	//フレネル効果
	};

	//バンプタイプ列挙定数
	enum BUMP_TYPE
	{
		BUMP_NORMAL_MAPPING		= 0,
		BUMP_PARALLAX_MAPPING	= 1,
	};

	//ウェーブタイプ
	enum WAVE_TYPE
	{
		WAVE_NORMAL		= 0,	// 通常
		WAVE_REFRACT	= 1,	// 屈折効果
	};

	//ウェーブ方向列挙定数
	enum WAVE_DIR
	{
		WAVE_NEGATIVE_U = 0,	// テクスチャ空間の左方向
		WAVE_POSITIVE_U = 1,	// テクスチャ空間の右方向
		WAVE_NEGATIVE_V = 2,	// テクスチャ空間の上方向
		WAVE_POSITIVE_V = 3,	// テクスチャ空間の下方向
	};

	//半透明メソッド列挙定数
	enum TRANSPARENCY_METHOD
	{
		TRANSPARENCY_LUMP		= 0,	// 一括描画
		TRANSPARENCY_INDIVIDUAL	= 1,	// ポリゴン単位での描画

		TRANSPARENCY_METHOD_MAX = 2,
	};

	//マテリアルコンパイルフラグ列挙定数
	enum MATERIAL_COMPILE_FLAG
	{
		MCF_NORMAL					= 0x00000001,
		MCF_TANGENT_SPACE			= 0x00000002,
		MCF_TEXTURE					= 0x00000004,

		MCF_SIMPLE_VERTEX			= 0x00000008,
		MCF_BLEND_VERTEX			= 0x00000010,

		MCF_LIGHTING				= 0x00000020,
		MCF_BOTH_LIGHTING			= 0x00000040,
		MCF_SHADOW_RECEIVE			= 0x00000080,

		MCF_REFRACT_CLIP			= 0x00000100,

		MCF_DIFFUSE_HALF_LAMBERT	= 0x00000200,
		MCF_DIFFUSE_MAPPING			= 0x00000400,
		MCF_DIFFUSE_FRESNEL			= 0x00000800,
		MCF_DIFFUSE_RIM_LIGHTING	= 0x00001000,

		MCF_SPECULAR_PHONG			= 0x00002000,
		MCF_SPECULAR_BLINN_PHONG	= 0x00004000,
		MCF_SPECULAR_COOK_TORRANCE	= 0x00008000,
		MCF_SPECULAR_MAPPING		= 0x00010000,

		MCF_REFLECT_MAPPING			= 0x00020000,
		MCF_REFLECT_FRESNEL			= 0x00040000,

		MCF_EMISSIVE_MAPPING		= 0x00080000,

		MCF_BUMP_MAPPING			= 0x00100000,
		MCF_PARALLAX				= 0x00200000,
		MCF_WATER					= 0x00400000,
		MCF_REFRACT_MAPPING			= 0x00800000,

		MCF_SOFTPARTICLE			= 0x01000000,

		MCF_WAVE_INVERT				= 0x02000000,

		MCF_ATMOSPHERE				= 0x10000000,
		MCF_FOG						= 0x20000000,
		MCF_SHADOW					= 0x40000000,
		MCF_SSAO					= 0x80000000,

		//マスク
		MCF_SIMPLE_MASK				=	0xFFFFFFEF, //~MCF_BLEND_VERTEX
		MCF_BLEND_MASK				=	0xFFFFFFF7, //~MCF_SIMPLE_VERTEX
		MCF_SPECULAR_MASK			=	MCF_SPECULAR_PHONG |
										MCF_SPECULAR_BLINN_PHONG |
										MCF_SPECULAR_COOK_TORRANCE |
										MCF_SPECULAR_MAPPING,

		//バーテックスレイアウトのIDマスク( コンパイルには使用しません )
		MCF_ID_VERTEX_LAYOUT_MASK	=	MCF_NORMAL |
										MCF_TANGENT_SPACE |
										MCF_TEXTURE |
										MCF_SIMPLE_VERTEX |
										MCF_BLEND_VERTEX,

		//バーテックスシェーダーのIDマスク( コンパイルには使用しません )
		MCF_ID_VERTEX_SHADER_MASK	=	MCF_NORMAL |
										MCF_TANGENT_SPACE |
										MCF_TEXTURE |
										MCF_SIMPLE_VERTEX |
										MCF_BLEND_VERTEX |
										MCF_LIGHTING |
										MCF_SHADOW_RECEIVE |
										MCF_BUMP_MAPPING |
										MCF_REFRACT_MAPPING |
										MCF_SSAO,

		//ピクセルシェーダーのIDマスク( コンパイルには使用しません )
		MCF_ID_PIXEL_SHADER_MASK	=	MCF_TEXTURE |
										MCF_LIGHTING |
										MCF_BOTH_LIGHTING |
										MCF_SHADOW_RECEIVE |
										MCF_REFRACT_CLIP |
										MCF_DIFFUSE_HALF_LAMBERT |
										MCF_DIFFUSE_MAPPING |
										MCF_DIFFUSE_FRESNEL |
										MCF_DIFFUSE_RIM_LIGHTING |
										MCF_SPECULAR_PHONG |
										MCF_SPECULAR_BLINN_PHONG |
										MCF_SPECULAR_COOK_TORRANCE |
										MCF_SPECULAR_MAPPING |
										MCF_REFLECT_MAPPING |
										MCF_REFLECT_FRESNEL |
										MCF_EMISSIVE_MAPPING |
										MCF_BUMP_MAPPING |
										MCF_PARALLAX |
										MCF_WATER |
										MCF_REFRACT_MAPPING |
										MCF_SOFTPARTICLE |
										MCF_WAVE_INVERT |
										MCF_ATMOSPHERE |
										MCF_FOG |
										MCF_SHADOW |
										MCF_SSAO, 
	};

	//バーテックスタイプ
	enum VERTEX_TYPE
	{
		VERTEX_SIMPLE	= 0,
		VERTEX_BLEND	= 1,

		VERTEX_UNKNOWN	= 0xFFFFFFFF,	//不明
	};

	//バーテックスタイプ最大数
	static const unsigned int VERTEX_TYPE_MAX = 2;

	//マッピングタイプ
	enum MAPPING_TYPE
	{
		MAPPING_COLOR	= 0,	//カラー
		MAPPING_MASK	= 1,	//マスク
	};

	//マッピングタイプ最大数
	static const unsigned int MAPPING_TYPE_MAX = 2;

	//インデックスタイプ
	enum INDEX_TYPE
	{
		INDEX_USHORT	= 0,
		INDEX_UINT		= 1,

		INDEX_UNKNOWN	= 0xFFFFFFFF,	//不明
	};

	//インデックスタイプ最大数
	static const unsigned int INDEX_TYPE_MAX = 2;

	//ラインバーテックス構造体
	struct LINE_VERTEX
	{
		D3DXVECTOR4 pos;
		D3DXVECTOR4 color;

		LINE_VERTEX( void ) {}
		LINE_VERTEX( const D3DXVECTOR4& p, const D3DXVECTOR4& c )
		{
			pos = p;
			color = c;
		}
	};

	//クワッドバーテックス構造体
	struct QUAD_VERTEX
	{
		D3DXVECTOR4 pos;
		D3DXVECTOR2 tex;

		QUAD_VERTEX( void )
		{
			pos = D3DXVECTOR4( 0.0f, 0.0f, 0.0f, 1.0f );
			tex = D3DXVECTOR2( 0.0f, 0.0f );
		}

		QUAD_VERTEX( float x, float y, float u, float v )
		{
			pos.x = x;
			pos.y = y;
			pos.z = 0.0f;
			pos.w = 1.0f;

			tex.x = u;
			tex.y = v;
		}
	};

	//バーテックスシェーダーのレジスタ
	enum VSR
	{
		VSR_V_MAT			= 16,
		VSR_VP_MAT			= 20,
		VSR_WORLD_MAT		= 32,
	};
	
	//ピクセルシェーダーのレジスタ
	enum PSR
	{
		PSR_CAMERA_INV_FARZ		= 16,
		PSR_EYE_POS				= 17,

		PSR_AMBIENT_LIGHT_COLOR	= 18,

		PSR_HS_LIGHT_AXIS		= 19,

		PSR_SUN_LIGHT_DIR		= 22,
		PSR_SUN_LIGHT_COLOR		= 23,

		PSR_FOG_PARAM			= 24,

		PSR_SHADOW_PARAM		= 26,

		PSR_LOCAL_LIGHT			= 48,

		PSR_AMBIENT_COLOR		= 68,
		PSR_DIFFUSE_COLOR		= 69,
		PSR_DIFFUSE_PARAM		= 70,
		PSR_SPEUCLAR_COLOR		= 71,
		PSR_SPEUCLAR_PARAM0		= 72,
		PSR_SPEUCLAR_PARAM1		= 73,
		PSR_REFLECT_PARAM		= 74,
		PSR_EMISSIVE_COLOR		= 75,
		PSR_EMISSIVE_PARAM		= 76,
		PSR_BUMP_PARAM0			= 77,
		PSR_BUMP_PARAM1			= 78,
		PSR_TRANSPARENCY_PARAM	= 79,
	};

	//テクスチャステージ
	enum TS
	{
		TS_DIFFUSE_TEXTURE		= 0,
		TS_SPEUCLAR_TEXTURE		= 1,
		TS_EMISSIVE_TEXTURE		= 2,
		TS_BUMP_TEXTURE			= 3,

		TS_DEPTH_TEXTURE		= 4,
		TS_SHADOW_TEXTURE		= 5,
		TS_REFRACT_TEXTURE		= 6,
		TS_REFRECT_TEXTURE		= 7,
	};

	//平面構造体
	struct PLANE
	{
		D3DXVECTOR3 normal;
		float d;

		static void Compute(	const D3DXVECTOR3& p0,
								const D3DXVECTOR3& p1,
								const D3DXVECTOR3& p2,
								PLANE& plane )
		{
			D3DXVECTOR3 v1;
			D3DXVECTOR3 v2;

			v1 = ( p1 - p0 );
			v2 = ( p2 - p0 );

			D3DXVec3Cross( &( plane.normal ), &v1, &v2 );
			D3DXVec3Normalize( &( plane.normal ), &( plane.normal ) );

			plane.d = -D3DXVec3Dot( &( plane.normal ), &p0 );
		}
	};

	//ウェイト構造体
	struct WEIGHT
	{
		unsigned int index;
		float value;

		WEIGHT( void ) :
		index( 0 ),
		value( 0.0f )
		{
		}

		bool operator()( const WEIGHT& l, const WEIGHT& r )
		{
			return ( l.value > r.value );
		}
	};

	//バーテックス構造体
	struct VERTEX
	{
		D3DXVECTOR3 pos;
		D3DXVECTOR4 color;
		D3DXVECTOR3 normal;
		D3DXVECTOR2 tex;
		Mix::Tool::Win32::Graphics::WEIGHT weights[Mix::Tool::Win32::Graphics::MAX_VERTEX_WEIGHT];
	};

	//ブランクバーテックス構造体
	struct BLANK_VERTEX
	{
		D3DXVECTOR3 pos;
		unsigned int indices[Mix::Tool::Win32::Graphics::MAX_VERTEX_WEIGHT];
		float weights[Mix::Tool::Win32::Graphics::MAX_VERTEX_WEIGHT];
	};

	//ポリゴン構造体
	struct POLYGON
	{
		unsigned int materialNo;
		std::vector<Mix::Tool::Win32::Graphics::VERTEX> vertices;

		bool operator()( const Mix::Tool::Win32::Graphics::POLYGON& l, const Mix::Tool::Win32::Graphics::POLYGON& r )
		{
			return ( l.materialNo < r.materialNo );
		}
	};

	//ベースシェイプ構造体
	struct BASE_SHAPE
	{
		std::wstring name;
		Mix::Tool::Win32::Geometry::OBB obb;

		bool operator()( const Mix::Tool::Win32::Graphics::BASE_SHAPE& l, const Mix::Tool::Win32::Graphics::BASE_SHAPE& r )
		{
			return ( l.name < r.name );
		}
	};

	//ビルドタイプ列挙定数
	enum MESH_BUILD_TYPE
	{
		MESH_BUILD_DIRECT	= 0,	// 最適化しない
		MESH_BUILD_OPTIMIZE	= 1,	// 最適化する
	};

	//ボーン構造体
	struct BONE
	{
		std::wstring name;
		D3DXMATRIX offsetMatrix;
	};

	//カーブキー構造体
	struct CURVE_KEY
	{
		int time;
		float value;
	};

	//クォータニオンキー
	struct QUATERNION_KEY
	{
		float time;
		D3DXQUATERNION value;

		QUATERNION_KEY( void )
		{
			time = 0.0f;
			D3DXQuaternionIdentity( &value );
		}

		QUATERNION_KEY( const D3DXQUATERNION& _value )
		{
			time = 0.0f;
			value = _value;
		}

		QUATERNION_KEY( float _time, const D3DXQUATERNION& _value )
		{
			time = _time;
			value = _value;
		}

		bool operator () ( const QUATERNION_KEY& l, const QUATERNION_KEY& r )
		{
			return l.time < r.time;
		}

		bool operator () ( const float& l, const QUATERNION_KEY& r )
		{
			return l < r.time;
		}

		bool operator () ( const QUATERNION_KEY& l, const float& r )
		{
			return l.time < r;
		}
	};

	//クォータニオンキーリスト
	typedef std::vector<Mix::Tool::Win32::Graphics::QUATERNION_KEY> QuaternionKeyList;

	//ベクターキー
	struct VECTOR_KEY
	{
		float time;
		D3DXVECTOR3 value;

		VECTOR_KEY( void )
		{
			time = 0.0f;
			value = D3DXVECTOR3( 0.0f, 0.0f, 0.0f );
		}

		VECTOR_KEY( const D3DXVECTOR3& _value )
		{
			time = 0.0f;
			value = _value;
		}

		VECTOR_KEY( float _time, const D3DXVECTOR3& _value )
		{
			time = _time;
			value = _value;
		}

		bool operator () ( const VECTOR_KEY& l, const VECTOR_KEY& r )
		{
			return l.time < r.time;
		}

		bool operator () ( const float& l, const VECTOR_KEY& r )
		{
			return l < r.time;
		}

		bool operator () ( const VECTOR_KEY& l, const float& r )
		{
			return l.time < r;
		}
	};

	//ベクターキーリスト
	typedef std::vector<Mix::Tool::Win32::Graphics::VECTOR_KEY> VectorKeyList;

	//ルートトランスフォームブレンド構造体
	struct RT_BLEND
	{
		unsigned int priority;
		float ratio;
		D3DXQUATERNION angularVelocity;
		D3DXVECTOR3 linearVelocity;

		bool operator()( const Mix::Tool::Win32::Graphics::RT_BLEND& l, const Mix::Tool::Win32::Graphics::RT_BLEND& r )
		{
			return ( l.priority < r.priority );
		}
	};

	//ボディトランスフォームブレンド構造体
	struct BT_BLEND
	{
		unsigned int priority;
		unsigned int nodeIndex;
		float ratio;
		D3DXVECTOR3 scaling;
		D3DXQUATERNION rotation;
		D3DXVECTOR3 translation;

		bool operator()( const Mix::Tool::Win32::Graphics::BT_BLEND& l, const Mix::Tool::Win32::Graphics::BT_BLEND& r )
		{
			return ( l.priority < r.priority );
		}
	};

	//モーション : ルートトランスフォーム : フラグ列挙定数
	enum MOTION_ROOT_TRANSFORM_FLAG
	{
		MOTION_RT_ROTATION			= 0x00000001,	//回転

		MOTION_RT_TRANSLATION_XZ	= 0x00000002,	//移動(XZ)
		MOTION_RT_TRANSLATION_Y		= 0x00000004,	//移動(Y)
		MOTION_RT_TRANSLATION		= 0x00000006,	//移動

		MOTION_RT_MASK				= 0x00000007,	//マスク
	};

	//モーション : ルートトランスフォーム : 水平面列挙定数
	enum MOTION_RT_HORIZONAL
	{
		MOTION_RT_H_XY	= 0,	//XY
		MOTION_RT_H_XZ	= 1,	//XZ
		MOTION_RT_H_YZ	= 2,	//YZ
	};

	//モーション : ルートトランスフォーム : 鉛直方向列挙定数
	enum MOTION_RT_VERTICAL
	{
		MOTION_RT_V_X	= 0,	//X
		MOTION_RT_V_Y	= 1,	//Y
		MOTION_RT_V_Z	= 2,	//Z
	};

	//モーション : ルートトランスフォーム : ベクター列挙定数
	enum MOTION_RT_VECTOR
	{
		MOTION_RT_NEGATIVE_X	= 0,	//-X
		MOTION_RT_POSITIVE_X	= 1,	//+X
		MOTION_RT_NEGATIVE_Y	= 2,	//-Y
		MOTION_RT_POSITIVE_Y	= 3,	//+Y
		MOTION_RT_NEGATIVE_Z	= 4,	//-Z
		MOTION_RT_POSITIVE_Z	= 5,	//+Z
	};

	//モーション : ルートトランスフォームアクシズ構造体
	struct MOTION_RT_AXIS
	{
		MOTION_RT_VECTOR x;
		MOTION_RT_VECTOR y;
		MOTION_RT_VECTOR z;

		MOTION_RT_AXIS( void )
		{
			x = MOTION_RT_POSITIVE_X;
			y = MOTION_RT_POSITIVE_Y;
			z = MOTION_RT_POSITIVE_Z;
		}

		MOTION_RT_AXIS( MOTION_RT_VECTOR _x, MOTION_RT_VECTOR _y, MOTION_RT_VECTOR _z )
		{
			x = _x;
			y = _y;
			z = _z;
		}

		bool operator != ( const MOTION_RT_AXIS& r ) const
		{
			if( ( x != r.x ) ||
				( y != r.y ) ||
				( z != r.z ) )
			{
				return true;
			}

			return false;
		}
	};

	//モーション : ステート列挙定数
	enum MOTION_STATE
	{
		MOTION_PLAY = 0,	//再生
		MOTION_PAUSE = 1,	//一時停止
		MOTION_STOP	= 2,	//停止
	};

	//ベースサブセット構造体
	struct BASE_SUBSET
	{
		unsigned int boneCount;
		const D3DXMATRIX* boneMatTable;

		unsigned int vertexStart;
		unsigned int vertexNum;
		unsigned int indexStart;
		unsigned int indexNum;

		Mix::Tool::Win32::Graphics::VertexLayout* pCommonVL;

		Mix::Tool::Win32::Graphics::VertexShader* pColorVS;
		Mix::Tool::Win32::Graphics::PixelShader* pColorPS;

		Mix::Tool::Win32::Graphics::VertexBuffer* pVertexBuffer;
		Mix::Tool::Win32::Graphics::IndexBuffer* pIndexBuffer;
	};

	//カラーサブセット構造体
	struct COLOR_SUBSET : public BASE_SUBSET
	{
		Mix::Tool::Win32::Graphics::Material* pMaterial;

		Mix::Tool::Win32::Graphics::VertexShader* pSelectVS;
		Mix::Tool::Win32::Graphics::PixelShader* pSelectPS;

		D3DXVECTOR4 selectColor;
	};

	//不透明サブセット構造体
	struct OPACITY_SUBSET : public COLOR_SUBSET
	{
		unsigned int sortKey;

		bool operator()( const OPACITY_SUBSET& l, const OPACITY_SUBSET& r )
		{
			return ( l.sortKey < r.sortKey );
		}
	};

	//半透明サブセット構造体
	struct TRANSPARENCY_SUBSET : public COLOR_SUBSET
	{
		D3DXVECTOR4 sortKey;

		bool operator()( const TRANSPARENCY_SUBSET& l, const TRANSPARENCY_SUBSET& r )
		{
			return ( l.sortKey.z > r.sortKey.z );
		}
	};

	//リフラクトサブセット構造体
	struct REFRACT_SUBSET : public COLOR_SUBSET
	{
		Mix::Tool::Win32::Graphics::VertexShader* pMaskVS;
		Mix::Tool::Win32::Graphics::PixelShader* pMaskPS;

		unsigned int sortKey;

		bool operator()( const REFRACT_SUBSET& l, const REFRACT_SUBSET& r )
		{
			return ( l.sortKey < r.sortKey );
		}
	};

	//物理 : マテリアル構造体
	struct PHYSICS_MATERIAL
	{
		int id;
		int attr;
		float friction;
		float restitution;
	};

	//物理 : リジッドボディ構造体
	struct PHYSICS_RIGIDBODY
	{
		float mass;
		float gravityAcceleration;
		float linearDamping;
		float angularDamping;
	};

}}}}
