#pragma once

//! @file Mix/Common.h
//! @brief 共通インクルードファイル

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// インクルード
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#include <windows.h>
#include <vector>
#include <list>
#include <map>

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 警告の無効化
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#pragma warning ( disable: 4100 )	//関数の引数を一度も参照してないときにでる警告を無視( インターフェースの派生など )
#pragma warning ( disable: 4201 )	//無名構造体の警告を無視
#pragma warning ( disable: 4786 )	//255文字より長いシンボルの警告を無視

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 定義
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

//! @name DLL
//! @{

#ifdef _MIX_DLL
	#ifdef _MIX_DLL_EXPORTS
		//! @def _MIX_DLL_API
		//! @brief DLLエクスポート定義
		#define _MIX_DLL_API __declspec( dllexport )
	#else // _MIX_DLL_EXPORTS
		//! @def _MIX_DLL_API
		//! @brief DLLインポート定義
		#define _MIX_DLL_API __declspec( dllimport )
	#endif // _MIX_DLL_EXPORTS
#else //_MIX_DLL
	//! @def _MIX_DLL_API
	//! @brief DLL定義
	#define _MIX_DLL_API
#endif //_MIX_DLL

//! @}

//! @name 変数型
//! @{

//! @typedef Int8
//! @brief 符号有り8ビット整数
typedef char Int8;
//! @typedef UInt8
//! @brief 符号無し8ビット整数
typedef unsigned char UInt8;
//! @typedef Int16
//! @brief 符号有り16ビット整数
typedef short Int16;
//! @typedef UInt16
//! @brief 符号無し16ビット整数
typedef unsigned short UInt16;
//! @typedef Int32
//! @brief 符号有り32ビット整数
typedef int Int32;
//! @typedef UInt32
//! @brief 符号無し32ビット整数
typedef unsigned int UInt32;
//! @typedef Int64
//! @brief 符号有り64ビット整数
typedef long long Int64;
//! @typedef UInt64
//! @brief 符号無し64ビット整数
typedef unsigned long long UInt64;
//! @typedef Long32
//! @brief 符号有り32ビット整数
typedef long Long32;
//! @typedef ULong32
//! @brief 符号無し32ビット整数
typedef unsigned long ULong32;
//! @typedef Float32
//! @brief 32ビット浮動小数点
typedef float Float32;
//! @typedef Float64
//! @brief 64ビット浮動小数点
typedef double Float64;

//! @var typedef IntT
//! @brief 符号有り整数
#ifdef _WIN64
typedef long long IntT;
#else //_WIN64
typedef int IntT;
#endif //_WIN64

//! @var typedef UIntT
//! @brief 符号無し整数
typedef size_t UIntT;

//! @var typedef BOOL Boolean
//! @brief 32ビットブーリアン
typedef BOOL Boolean;
//! @def True
//! @brief Boolean型の真値
#define True TRUE
//! @def False
//! @brief Boolean型の偽値
#define False FALSE

//! @}

#ifdef _DEBUG

	//! @name アサート
	//! 致命的なエラーをメッセージボックスで表示した後、アプリケーションを強制終了します。
	//! @{

	//! @def MIX_ASSERT
	//! @brief 標準のアサート
	#define MIX_ASSERT( cnd ) \
		if( !( cnd ) ) \
		{ \
			char text[1024]; \
			::sprintf_s( text, sizeof( text ), "File : \"%s\"\nLine : %d\nCondition : %s", __FILE__, __LINE__, #cnd ); \
			::MessageBoxA( ::GetActiveWindow(), text, "Assert", MB_OK | MB_ICONSTOP ); \
			*( ( int* )0x0 ) = 0x0; \
		}

	//! @def MIX_ASSERT_EX_W
	//! @brief 拡張アサート ( ユニコード )
	#define MIX_ASSERT_EX_W( cnd, mes, ... ) \
		if( !( cnd ) ) \
		{ \
			wchar_t fmt[1024] = L"File : \"%s\"\nLine : %d\nCondition : %s\n\n"; \
			wchar_t text[1024]; \
			::wcscat_s( fmt, ( sizeof( fmt ) >> 1 ), mes ); \
			::swprintf_s( text, fmt, __FILEW__, __LINE__, L#cnd, __VA_ARGS__ ); \
			::MessageBoxW( ::GetActiveWindow(), text, L"Assert", MB_OK | MB_ICONSTOP ); \
			*( ( int* )0x0 ) = 0x0; \
		}

	//! @def MIX_ASSERT_EX_A
	//! @brief 拡張アサート ( マルチバイト )
	#define MIX_ASSERT_EX_A( cnd, mes, ... ) \
		if( !( cnd ) ) \
		{ \
			char fmt[1024] = "File : \"%s\"\nLine : %d\nCondition : %s\n\n"; \
			char text[1024]; \
			::strcat_s( fmt, sizeof( fmt ), mes ); \
			::sprintf_s( text, sizeof( text ), fmt, __FILE__, __LINE__, #cnd, __VA_ARGS__ ); \
			::MessageBoxA( ::GetActiveWindow(), text, "Assert", MB_OK | MB_ICONSTOP ); \
			*( ( int* )0x0 ) = 0x0; \
		}

	//! @def MIX_ASSERT_EX
	//! @brief 標準の拡張アサート
	#define MIX_ASSERT_EX MIX_ASSERT_EX_W

	//! @}

	//! @name エラー
	//! エラーをメッセージボックスとして表示します。<br>
	//! また、アサートのようにアプリケーションは強制終了しません。
	//! @{

	//! @def MIX_ERROR_W
	//! @brief エラー ( ユニコード )
	#define MIX_ERROR_W( mes, ... ) \
		{ \
			wchar_t fmt[1024] = L"File : \"%s\"\nLine : %d\n\n"; \
			wchar_t text[1024]; \
			::wcscat_s( fmt, ( sizeof( fmt ) >> 1 ), mes ); \
			::swprintf_s( text, fmt, __FILEW__, __LINE__, __VA_ARGS__ ); \
			::MessageBoxW( ::GetActiveWindow(), text, L"Error", MB_OK | MB_ICONSTOP ); \
		}

	//! @def MIX_ERROR_A
	//! @brief エラー ( マルチバイト )
	#define MIX_ERROR_A( mes, ... ) \
		{ \
			char fmt[1024] = "File : \"%s\"\nLine : %d\n\n"; \
			char text[1024]; \
			::strcat_s( fmt, sizeof( fmt ), mes ); \
			::sprintf_s( text, sizeof( text ), fmt, __FILE__, __LINE__, __VA_ARGS__ ); \
			::MessageBoxA( ::GetActiveWindow(), text, "Error", MB_OK | MB_ICONSTOP ); \
		}

	//! @def MIX_ERROR
	//! @brief 標準のエラーの通知
	#define MIX_ERROR MIX_ERROR_W

	//! @}

	//! @name トレース
	//! デバッガの出力に表示します。
	//! @{

	//! @def MIX_TRACE_W
	//! @brief トレース ( ユニコード )
	#define MIX_TRACE_W( fmt, ... ) \
		{ \
			wchar_t text[1024] = L""; \
			::swprintf_s( text, fmt, __VA_ARGS__ ); \
			::OutputDebugStringW( text ); \
		}

	//! @def MIX_TRACE_A
	//! @brief トレース ( マルチバイト )
	#define MIX_TRACE_A( fmt, ... ) \
		{ \
			char text[1024] = ""; \
			::sprintf_s( text, sizeof( text ), fmt, __VA_ARGS__ ); \
			::OutputDebugStringA( text ); \
		}

	//! @def MIX_TRACE
	//! @brief 標準のトレース
	#define MIX_TRACE MIX_TRACE_W

	//! @def MIX_TRACELINE_W
	//! @brief トレースライン ( ユニコード )
	#define MIX_TRACELINE_W( fmt, ... ) \
		{ \
			wchar_t text[1024] = L""; \
			::swprintf_s( text, fmt, ##__VA_ARGS__ ); \
			::wcscat_s( text, sizeof( text ) >> 1, L"\n" ); \
			::OutputDebugStringW( text ); \
		}

	//! @def MIX_TRACELINE_A
	//! @brief トレースライン ( マルチバイト )
	#define MIX_TRACELINE_A( fmt, ... ) \
		{ \
			char text[1024] = ""; \
			::sprintf_s( text, sizeof( text ), fmt, __VA_ARGS__ ); \
			::strcat_s( text, sizeof( text ), "\n" ); \
			::OutputDebugStringA( text ); \
		}

	//! @def MIX_TRACELINE
	//! @brief 標準のトレースライン
	#define MIX_TRACELINE MIX_TRACELINE_W

	//! @}

	//! @name デバッグ
	//! @{

	//! @struct MIX_DEBUGNAME_STRUCT
	//! @brief デバッグ名構造体
	struct MIX_DEBUGNAME_STRUCT
	{
	private:
		wchar_t text[512];

	public:
		//! @brief コンストラクタ
		//! @param[in] fileName ファイル名
		//! @param[in] line 行
		MIX_DEBUGNAME_STRUCT( const wchar_t* fileName, UInt32 line )
		{
			::wsprintfW( text, L"%s[%d]", fileName, line );
		}

		//! @brief コンストラクタ
		//! @param[in] title タイトル
		//! @param[in] fileName ファイル名
		//! @param[in] line 行
		MIX_DEBUGNAME_STRUCT( const wchar_t* title, const wchar_t* fileName, UInt32 line )
		{
			::wsprintfW( text, L"%s : %s[%d]", title, fileName, line );
		}

		//! @brief 型変換
		//! @return 生成されたデバッグネーム
		operator const wchar_t*( void )
		{
			return text;
		}
	};

	//! @def MIX_DEBUGNAME
	//! @brief デバッグ名
	#define MIX_DEBUGNAME MIX_DEBUGNAME_STRUCT( __FILEW__, __LINE__ )
	//! @def MIX_DEBUGNAME_T
	//! @brief デバッグ名( タイトルあり )
	#define MIX_DEBUGNAME_T( title ) MIX_DEBUGNAME_STRUCT( title, __FILEW__, __LINE__ )

	//! @}

	/// @cond _INTERNAL

	namespace Mix
	{
		_MIX_DLL_API Int8 IntT_ToInt8( IntT value );
		_MIX_DLL_API Int16 IntT_ToInt16( IntT value );
#ifdef _WIN64
		_MIX_DLL_API Int32 IntT_ToInt32( IntT value );
#else //_WIN64
		_MIX_DLL_API IntT Int64_ToIntT( Int64 value );
#endif //_WIN64

		_MIX_DLL_API UInt8 IntT_ToUInt8( IntT value );
		_MIX_DLL_API UInt16 IntT_ToUInt16( IntT value );
		_MIX_DLL_API UInt32 IntT_ToUInt32( IntT value );

		_MIX_DLL_API UInt8 UIntT_ToUInt8( UIntT value );
		_MIX_DLL_API UInt16 UIntT_ToUInt16( UIntT value );
#ifdef _WIN64
		_MIX_DLL_API UInt32 UIntT_ToUInt32( UIntT value );
#else //_WIN64
		_MIX_DLL_API UIntT UInt64_ToUIntT( UInt64 value );
#endif //_WIN64

		_MIX_DLL_API Int8 UIntT_ToInt8( UIntT value );
		_MIX_DLL_API Int16 UIntT_ToInt16( UIntT value );
		_MIX_DLL_API Int32 UIntT_ToInt32( UIntT value );
	}

	/// @endcond

	//! @name 変数のキャスト
	//! @{

	//! @def MIX_IT_TO_I8
	//! @brief IntT から Int8 にキャストします
	#define MIX_IT_TO_I8( value ) Mix::IntT_ToInt8( value )
	//! @def MIX_IT_TO_I16
	//! @brief IntT から Int16 にキャストします
	#define MIX_IT_TO_I16( value ) Mix::IntT_ToInt16( value )
#ifdef _WIN64
	//! @def MIX_IT_TO_I32
	//! @brief IntT から Int32 にキャストします
	#define MIX_IT_TO_I32( value ) Mix::IntT_ToInt32( value )
	//! @def MIX_IT64_TO_IT
	//! @brief Int64 から IntT にキャストします
	#define MIX_IT64_TO_IT( value ) value
#else //_WIN64
	//! @def MIX_IT_TO_I32
	//! @brief IntT から Int32 にキャストします
	#define MIX_IT_TO_I32( value ) value
	//! @def MIX_IT64_TO_IT
	//! @brief Int64 から IntT にキャストします
	#define MIX_IT64_TO_IT( value ) Mix::Int64_ToIntT( value )
#endif //_WIN64

	//! @def MIX_IT_TO_UI8
	//! @brief IntT から UInt8 にキャストします
	#define MIX_IT_TO_UI8( value ) Mix::IntT_ToUInt8( value )
	//! @def MIX_IT_TO_UI16
	//! @brief IntT から UInt16 にキャストします
	#define MIX_IT_TO_UI16( value ) Mix::IntT_ToUInt16( value )
	//! @def MIX_IT_TO_UI32
	//! @brief IntT から UInt32 にキャストします
	#define MIX_IT_TO_UI32( value ) Mix::IntT_ToUInt32( value )

	//! @def MIX_UIT_TO_UI8
	//! @brief UIntT から UInt8 にキャストします
	#define MIX_UIT_TO_UI8( value ) Mix::UIntT_ToUInt8( value )
	//! @def MIX_UIT_TO_UI16
	//! @brief UIntT から UInt16 にキャストします
	#define MIX_UIT_TO_UI16( value ) Mix::UIntT_ToUInt16( value )
#ifdef _WIN64
	//! @def MIX_UIT_TO_UI32
	//! @brief UIntT から UInt32 にキャストします
	#define MIX_UIT_TO_UI32( value ) Mix::UIntT_ToUInt32( value )
	//! @def MIT_UI64_TO_UIT
	//! @brief UInt64 から UIntT にキャストします
	#define MIT_UI64_TO_UIT( value ) value
#else //_WIN64
	//! @def MIX_UIT_TO_UI32
	//! @brief UIntT から UInt32 にキャストします
	#define MIX_UIT_TO_UI32( value ) value
	//! @def MIT_UI64_TO_UIT
	//! @brief UInt64 から UIntT にキャストします
	#define MIT_UI64_TO_UIT( value ) Mix::UInt64_ToUIntT( value )
#endif //_WIN64

	//! @def MIX_UIT_TO_I8
	//! @brief UIntT から Int8 にキャストします
	#define MIX_UIT_TO_I8( value ) Mix::UIntT_ToInt8( value )
	//! @def MIX_UIT_TO_I16
	//! @brief UIntT から Int16 にキャストします
	#define MIX_UIT_TO_I16( value ) Mix::UIntT_ToInt16( value )
	//! @def MIX_UIT_TO_I32
	//! @brief UIntT から Int32 にキャストします
	#define MIX_UIT_TO_I32( value ) Mix::UIntT_ToInt32( value )

	//! @}

#else //_DEBUG

	#define MIX_ASSERT( cnd )
	#define MIX_ASSERT_EX_W( cnd, mes, ... )
	#define MIX_ASSERT_EX_A( cnd, mes, ... )
	#define MIX_ERROR_W( mes, ... )
	#define MIX_ERROR_A( mes, ... )
	#define MIX_TRACE_W( fmt, ... )
	#define MIX_TRACE_A( fmt, ... )
	#define MIX_TRACELINE_W( fmt, ... )
	#define MIX_TRACELINE_A( fmt, ... )
	#define MIX_ASSERT_EX( cnd, mes, ... )
	#define MIX_ERROR( mes, ... )
	#define MIX_TRACE( fmt, ... )
	#define MIX_TRACELINE( fmt, ... )
	#define MIX_DEBUGNAME L""
	#define MIX_DEBUGNAME_T( title ) L""

	#define MIX_IT_TO_I8( value ) static_cast<Int8>( value )
	#define MIX_IT_TO_I16( value ) static_cast<Int16>( value )
#ifdef _WIN64
	#define MIX_IT_TO_I32( value ) static_cast<Int32>( value )
	#define MIX_IT64_TO_IT( value ) value
#else //_WIN64
	#define MIX_IT_TO_I32( value ) value
	#define MIX_IT64_TO_IT( value ) static_cast<IntT>( value )
#endif //_WIN64

	#define MIX_IT_TO_UI8( value ) static_cast<UInt8>( value )
	#define MIX_IT_TO_UI16( value ) static_cast<UInt16>( value )
	#define MIX_IT_TO_UI32( value ) static_cast<UInt32>( value )

	#define MIX_UIT_TO_UI8( value ) static_cast<UInt8>( value )
	#define MIX_UIT_TO_UI16( value ) static_cast<UInt16>( value )
#ifdef _WIN64
	#define MIX_UIT_TO_UI32( value ) static_cast<UInt32>( value )
	#define MIT_UI64_TO_UIT( value ) value
#else //_WIN64
	#define MIX_UIT_TO_UI32( value ) value
	#define MIT_UI64_TO_UIT( value ) static_cast<UIntT>( value )
#endif //_WIN64

	#define MIX_UIT_TO_I8( value ) static_cast<Int8>( value )
	#define MIX_UIT_TO_I16( value ) static_cast<Int16>( value )
	#define MIX_UIT_TO_I32( value ) static_cast<Int32>( value )

#endif //_DEBUG

//! @name アラインメント
//! @{

//! @def MIX_ALIGN
//! @brief アラインメントを指定します
#define MIX_ALIGN( n ) _declspec( align( n ) )
//! @def MIX_ALIGN_16
//! @brief アラインメントを 16Byte で指定します
#define MIX_ALIGN_16 _declspec( align( 16 ) )

//! @}

//! @name 参照カウンタ ( Mix::Reference )
//! @{

//! @def MIX_ADD_REF
//! @brief Mix::Release インターフェースを継承したクラスの参照カウンタをインクリメントします
#define MIX_ADD_REF( x ) \
	if( x != NULL ) \
	{ \
		x->AddRef(); \
	}

//! @def MIX_RELEASE
//! @brief Mix::Release インターフェースを継承したクラスの参照カウンタをデクリメントします
#define MIX_RELEASE( x ) \
	if( x != NULL ) \
	{ \
		x->Release(); \
		x = NULL; \
	}

//! @}

//! @name ビット判定
//! @{

//! @def MIX_SETBIT
//! @brief ビットをセットします
#define MIX_SETBIT( flags, bit ) \
	if( ( flags & ( bit ) ) == 0 ) \
	{ \
		flags |= ( bit ); \
	}

//! @def MIX_RESETBIT
//! @brief ビットをリセットします
#define MIX_RESETBIT( flags, bit ) \
	if( ( flags & ( bit ) ) == ( bit ) ) \
	{ \
		flags ^= ( bit ); \
	}

//! @def MIX_TESTBIT
//! @brief ビットをテストします
#define MIX_TESTBIT( flags, bit ) ( ( flags ) & ( bit ) )

//! @}

//! @name 算術関係
//! @{

//! @def MIX_PI
//! @brief 円周率
#define MIX_PI 3.141592654f
//! @def MIX_2PI
//! @brief 円周率 * 2
#define MIX_2PI 6.283185308f
//! @def MIX_4PI
//! @brief 円周率 * 4
#define MIX_4PI 12.566370616f
//! @def MIX_HALF_PI
//! @brief 円周率 / 2
#define MIX_HALF_PI 1.570796327f
//! @def MIX_QUARTER_PI
//! @brief 円周率 / 4
#define MIX_QUARTER_PI 0.7853981635f

//! @def MIX_FLOAT_MIN
//! @brief 浮動小数点の最小値
#define MIX_FLOAT_MIN 1.175494351e-38F
//! @def MIX_FLOAT_MAX
//! @brief 浮動小数点の最大値
#define MIX_FLOAT_MAX 3.402823466e+38F
//! @def MIX_FLOAT_EPSILON
//! @brief 浮動小数点イプシロン
#define MIX_FLOAT_EPSILON 1.192092896e-07F

//! @def MIX_TO_RAD
//! @brief 指定された角度(度数法)をラジアン単位に変換します
#define MIX_TO_RAD( x ) ( MIX_PI * ( x ) / 180.0f )
//! @def MIX_TO_DEG
//! @brief 指定された角度(ラジアン)を度数法に変換します
#define MIX_TO_DEG( x ) ( ( x ) * 180.0f / MIX_PI )

//! @def MIX_FLOAT_IS_ZERO
//! @brief 浮動小数点の値が0かどうかを返します
#define MIX_FLOAT_IS_ZERO( a ) ( ( -MIX_FLOAT_EPSILON < ( a ) ) && ( MIX_FLOAT_EPSILON > ( a ) ) )
//! @def MIX_FLOAT_EQUAL
//! @brief 浮動小数点の値が等しいかどうかを返します
#define MIX_FLOAT_EQUAL( a, b ) ( ( ( ( a ) - MIX_FLOAT_EPSILON ) <= ( b ) ) && ( ( ( a ) + MIX_FLOAT_EPSILON ) >= ( b ) ) )
//! @def MIX_FLOAT_RECIPROCAL
//! @brief a の逆数を求めます
#define MIX_FLOAT_RECIPROCAL( a ) ( ( MIX_FLOAT_IS_ZERO( a ) == False )? ( 1.0f / ( a ) ) : 0.0f )
//! @def MIX_FLOAT_DIV
//! @brief a を b で除算します
#define MIX_FLOAT_DIV( a, b ) ( ( MIX_FLOAT_IS_ZERO( b ) == False )? ( ( a ) / ( b ) ) : 0.0f )
//! @def MIX_FLOAT_SATURATE
//! @brief a を 0.0f〜1.0f に飽和します
#define MIX_FLOAT_SATURATE( a ) ( ( ( a ) < MIX_FLOAT_EPSILON )? 0.0f : ( ( a ) > 1.0f )? 1.0f : ( a ) )
//! @def MIX_CLAMP
//! @brief b <= a >= c になるように a を飽和します
#define MIX_CLAMP( a, b, c ) ( ( ( b ) > ( a ) )? ( b ) : ( ( c ) < ( a ) )? ( c ) : ( a ) )

//! @}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 名前空間の定義 1
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

//! @namespace Mix::Memory
//! @brief メモリ
namespace Mix{ namespace Memory{

	class IBuffer;

	//! @enum SECTION_TYPE
	//! @brief セクションタイプ列挙定数
	enum SECTION_TYPE
	{
		SECTION_GENERAL		= 0,	//!< 全般
		SECTION_GRAPHICS	= 1,	//!< グラフィックス
		SECTION_SOUND		= 2,	//!< サウンド
		SECTION_DYNAMICS	= 3,	//!< ダイナミクス
		SECTION_SCENE		= 4,	//!< シーン
		SECTION_USER		= 5,	//!< ユーザー
	};

	//! @struct SECTION_INFO
	//! @brief セクション情報構造体
	struct SECTION_INFO
	{
		UIntT maxTotalAllocatedSize;	//!< 確保したメモリの最大のサイズ
		UIntT totalAllocatedSize;		//!< 確保したメモリのサイズ
		UIntT totalFreeSize;			//!< 解放されているメモリのサイズ
		UIntT releasableSize;			//!< 解放できるメモリのサイズ
	};

	//! @class STLAllocator
	//! @brief STL アロケータテンプレートクラス
	//! @tparam ST セクションタイプを表す Mix::Memory::SECTION_TYPE 列挙定数
	//! @tparam T アロケータでメモリを確保するインスタンスの型
	template<Mix::Memory::SECTION_TYPE ST, typename T>
	class STLAllocator
	{
		//! @cond _INTERNAL

	public:
		typedef T value_type;
		typedef T *pointer;
		typedef const T *const_pointer;
		typedef T &reference;
		typedef const T &const_reference;
		typedef size_t size_type;
		typedef ptrdiff_t difference_type;

		template <class U>
		struct rebind { typedef Mix::Memory::STLAllocator<ST, U> other; };

	public:
		STLAllocator( void ) {}
		STLAllocator( const STLAllocator& ) {}

		template <class U>
		STLAllocator( const STLAllocator<ST, U>& ) {}

		~STLAllocator( void ) {}

		pointer allocate( size_type num, void *hint = 0 ) { ( void )hint; return ( pointer )( Mix::Memory::Allocate( ST, sizeof( T ) * num, __FILEW__, __LINE__ ) ); }
		void deallocate( pointer p, size_type num ) { ( void )num; Mix::Memory::Free( p, __FILEW__, __LINE__ ); }

		void construct( pointer p, const T& value ) { new( p ) T( value ); }
		void destroy( pointer p ) { p->~T(); }

		pointer address( reference value ) const { return &value; }
		const_pointer address( const_reference value ) const { return &value; }

		size_type max_size() const { return ( std::numeric_limits<size_t>::max )() / sizeof( T ); }

		//! @endcond
	};

	//! @cond _INTERNAL

	template <Mix::Memory::SECTION_TYPE ST, typename T, typename U>
	bool operator == ( const Mix::Memory::STLAllocator<ST, T>& lhs, Mix::Memory::STLAllocator<ST, U> const & rhs ) { return true; }

	template <Mix::Memory::SECTION_TYPE ST, typename T, typename U>
	bool operator != ( const Mix::Memory::STLAllocator<ST, T>& lhs, Mix::Memory::STLAllocator<ST, U> const & rhs ) { return !( lhs == rhs ); }

	//! @endcond

	//! @brief STL のデフォルトアロケータ
	//! @tparam T メモリを確保するインスタンスの型
	template<typename T>
	using STLDefaultAllocator = STLAllocator<Mix::Memory::SECTION_USER, T>;

	//! @brief セクションの情報を取得します
	//! @param section セクション
	//! @return セクションの情報を表す Mix::Memory::SECTION_INFO 構造体を返します
	_MIX_DLL_API Mix::Memory::SECTION_INFO GetSectionInfo( UInt16 section );

	//! @brief メモリを確保します
	//! @param[in] section セクション
	//! @param[in] size 確保するメモリのサイズ
	//! @param[in] pSrcFile メモリを確保したソースファイルのパス( __FILEW__ )
	//! @param[in] srcLine メモリを確保したソースファイルの行( __LINE__ )
	//! @return 確保したメモリのポインタを返します
	//! @note
	//! バッファなどのメモリを確保する際は MIX_MALLOC または MIX_DEBUG_MALLOC を使用し、解放は MIX_FREE を使用してください。<br>
	//! また、インスタンスの初期化は、MIX_NEW または MIX_DEBUG_NEW を使用し、解放は MIX_DELETE MIX_DELETE_ARRAY MIX_DELETE_THIS を使用してください。
	_MIX_DLL_API void* Allocate( UInt16 section, UIntT size, const wchar_t* pSrcFile, Int32 srcLine );

	//! @brief メモリを確保します
	//! @param[in] section セクション
	//! @param[in] alignment 確保するメモリのアラインメント( バイト単位 )
	//! @param[in] size 確保するメモリのサイズ( バイト単位 )
	//! @param[in] pSrcFile メモリを確保したソースファイルのパス( __FILEW__ )
	//! @param[in] srcLine メモリを確保したソースファイルの行( __LINE__ )
	//! @return 確保したメモリのポインタを返します
	_MIX_DLL_API void* AllocateAligned( UInt16 section, UInt16 alignment, UIntT size, const wchar_t* pSrcFile, Int32 srcLine );

	//! @brief メモリを再確保します
	//! @param[in] ptr 再確保するメモリのポインタ
	//! @param[in] size 再確保するサイズ
	//! @param[in] pSrcFile メモリを確保したソースファイルのパス( __FILEW__ )
	//! @param[in] srcLine メモリを確保したソースファイルの行( __LINE__ )
	//! @return 成功した場合は、再確保したメモリのポインタを返します
	//! @note
	//! バッファなどのメモリの再確保をする際は MIX_REALLOC を使用してください。<br>
	//! また、再確保に失敗した場合、指定した再確保しようとしているメモリ ( ptr ) は解放されません。<br>
	//! Mix::Memory::Free ( MIX_FREE ) を使用して解放する必要があります。
	_MIX_DLL_API void* Reallocate( void* ptr, UIntT size, const wchar_t* pSrcFile, Int32 srcLine );

	//! @brief メモリを解放します
	//! @param[in] ptr 解放するメモリのポインタ
	//! @param[in] pSrcFile メモリを確保したソースファイルのパス( __FILEW__ )
	//! @param[in] srcLine メモリを確保したソースファイルの行( __LINE__ )
	//! @note メモリの解放は MIX_FREE を使用してください。
	_MIX_DLL_API void Free( void* ptr, const wchar_t* pSrcFile, Int32 srcLine );

	//! @brief メモリをコピーします
	//! @param[in] dst コピー先のメモリのポインタ
	//! @param[in] src コピー元のメモリのポインタ
	//! @param[in] size コピーするサイズ
	_MIX_DLL_API void Copy( void* dst, const void* src, UIntT size );

	//! @brief メモリ全体に指定した値を書き込みます
	//! @param[in] ptr メモリのポインタ
	//! @param[in] size メモリのサイズ
	//! @param[in] fill メモリに書き込む値
	_MIX_DLL_API void Fill( void* ptr, UIntT size, UInt8 fill );

	//! @brief メモリ全体に 0 を書き込みます
	//! @param[in] ptr メモリのポインタ
	//! @param[in] size メモリのサイズ
	_MIX_DLL_API void Zero( void* ptr, UIntT size );

	//! @brief バッファを作成します
	//! @param[in] section セクション
	//! @param[in] size バッファのサイズ
	//! @param[in] pInitialData バッファの初期データ( NULL指定可能 )
	//! @param[out] ppBuffer Mix::Memory::IBuffer インターフェースのポインタ
	_MIX_DLL_API Boolean CreateBuffer( UInt16 section, UIntT size, const void* pInitialData, Mix::Memory::IBuffer** ppBuffer );

}}

//! @name Mix のメモリ管理を使用した、メモリの確保、解放
//! @{

//! @def MIX_MALLOC
//! @brief メモリを、指定したサイズで確保します
#define MIX_MALLOC( size ) Mix::Memory::Allocate( Mix::Memory::SECTION_USER, size, __FILEW__, __LINE__ )
//! @def MIX_MALLOC_T
//! @brief メモリを、指定した型、数で確保します
#define MIX_MALLOC_T( T, count ) static_cast<T*>( Mix::Memory::Allocate( Mix::Memory::SECTION_USER, sizeof( T ) * count, __FILEW__, __LINE__ ) )
//! @def MIX_ALIGNED_MALLOC
//! @brief メモリを、指定したアライメント、サイズで確保します
#define MIX_ALIGNED_MALLOC( alignment, size ) Mix::Memory::Allocate( Mix::Memory::SECTION_USER, alignment, size, __FILEW__, __LINE__ )
//! @def MIX_ALIGNED_MALLOC_T
//! @brief メモリを、指定したアライメント、型、数で確保します
#define MIX_ALIGNED_MALLOC_T( alignment, T, count ) static_cast<T*>( Mix::Memory::Allocate( Mix::Memory::SECTION_USER, alignment, sizeof( T ) * count, __FILEW__, __LINE__ ) )

//! @def MIX_REALLOC
//! @brief 指定したメモリを指定したサイズで再確保します
#define MIX_REALLOC( ptr, size ) Mix::Memory::Reallocate( ptr, size )
//! @def MIX_REALLOC_T
//! @brief 指定したメモリを、指定した型、サイズで再確保します
#define MIX_REALLOC_T( ptr, T, count ) static_cast<T*>( Mix::Memory::Reallocate( ptr, sizeof( T ) * count ) )

//! @def MIX_FREE
//! @brief MIX_MALLOC もしくわ MIX_ALIGNED_MALLOC によって確保されたメモリを解放します
#define MIX_FREE( ptr ) \
	if( ptr != NULL ) \
	{ \
		Mix::Memory::Free( ptr, __FILEW__, __LINE__ ); \
		ptr = NULL; \
	}

//! @}

/// @cond _INTERNAL

inline void* operator new( size_t size, Mix::Memory::SECTION_TYPE secType, const wchar_t* srcFile, Int32 srcLine ) {
	return Mix::Memory::Allocate( secType, size, srcFile, srcLine ); }
inline void operator delete( void* ptr, Mix::Memory::SECTION_TYPE secType, const wchar_t* srcFile, Int32 srcLine ) {}

inline void* operator new[]( size_t size, Mix::Memory::SECTION_TYPE secType, const wchar_t* srcFile, Int32 srcLine ) {
	return Mix::Memory::Allocate( secType, size, srcFile, srcLine ); }
inline void operator delete[]( void* ptr, Mix::Memory::SECTION_TYPE secType, const wchar_t* srcFile, Int32 srcLine ) {}

inline void* operator new( size_t size, Mix::Memory::SECTION_TYPE secType, UInt16 align, const wchar_t* srcFile, Int32 srcLine ) {
	return Mix::Memory::AllocateAligned( secType, align, size, srcFile, srcLine ); }
inline void operator delete( void* ptr, Mix::Memory::SECTION_TYPE secType, UInt16 align, const wchar_t* srcFile, Int32 srcLine ) {}

inline void* operator new[]( size_t size, Mix::Memory::SECTION_TYPE secType, UInt16 align, const wchar_t* srcFile, Int32 srcLine ) {
	return Mix::Memory::AllocateAligned( secType, align, size, srcFile, srcLine ); }
inline void operator delete[]( void* ptr, Mix::Memory::SECTION_TYPE secType, UInt16 align, const wchar_t* srcFile, Int32 srcLine ) {}

/// @endcond

//! @name Mix のメモリ管理を使用した、インスタンスの作成、削除
//! @{

//! @def MIX_DECLARE_ALLOCATOR
//! @brief クラスにアロケータの定義を追加します
#define MIX_DECLARE_ALLOCATOR() \
	inline void* operator new( size_t size, Mix::Memory::SECTION_TYPE secType, const wchar_t* srcFile, Int32 srcLine ) { \
		return Mix::Memory::Allocate( secType, size, srcFile, srcLine ); } \
	inline void operator delete( void* ptr, Mix::Memory::SECTION_TYPE secType, const wchar_t* srcFile, Int32 srcLine ) {} \
	 \
	inline void* operator new[]( size_t size, Mix::Memory::SECTION_TYPE secType, const wchar_t* srcFile, Int32 srcLine ) { \
		return Mix::Memory::Allocate( secType, size, srcFile, srcLine ); }\
	inline void operator delete[]( void* ptr, Mix::Memory::SECTION_TYPE secType, const wchar_t* srcFile, Int32 srcLine ) {} \
	 \
	inline void* operator new( size_t size, Mix::Memory::SECTION_TYPE secType, UInt16 align, const wchar_t* srcFile, Int32 srcLine ) { \
		return Mix::Memory::AllocateAligned( secType, align, size, srcFile, srcLine ); } \
	inline void operator delete( void* ptr, Mix::Memory::SECTION_TYPE secType, UInt16 align, const wchar_t* srcFile, Int32 srcLine ) {} \
	 \
	inline void* operator new[]( size_t size, Mix::Memory::SECTION_TYPE secType, UInt16 align, const wchar_t* srcFile, Int32 srcLine ) { \
		return Mix::Memory::AllocateAligned( secType, align, size, srcFile, srcLine ); } \
	inline void operator delete[]( void* ptr, Mix::Memory::SECTION_TYPE secType, UInt16 align, const wchar_t* srcFile, Int32 srcLine ) {}

//! @def MIX_NEW_T
//! @brief 新しいインスタンスを指定した、インスタンスの型、コンストラクタに渡す引数で作成します
#define MIX_NEW_T( T, ... ) new( Mix::Memory::SECTION_USER, __FILEW__, __LINE__ ) T( __VA_ARGS__ )
//! @def MIX_ALIGNED_NEW_T
//! @brief 新しいインスタンスを指定した、アライメント、インスタンスの型、コンストラクタに渡す引数で作成します
#define MIX_ALIGNED_NEW_T( align, T, ... ) new( Mix::Memory::SECTION_USER, align, __FILEW__, __LINE__ ) T( __VA_ARGS__ )

//! @def MIX_DELETE_T
//! @brief MIX_NEW_T または MIX_ALIGNED_NEW_T によって作成されたインスタンスを削除します
#define MIX_DELETE_T( T, ptr ) \
	if( ptr != NULL ) \
	{ \
		ptr->~T(); \
		Mix::Memory::Free( ptr, __FILEW__, __LINE__ ); \
		ptr = NULL; \
	}

//! @def MIX_DELETE_THIS_T
//! @brief MIX_NEW_T または MIX_ALIGNED_NEW_T によって作成された自身のインスタンスを削除します
#define MIX_DELETE_THIS_T( T, ptr ) \
	ptr->~T(); \
	Mix::Memory::Free( ptr, __FILEW__, __LINE__ );

//! @def MIX_NEW_ARRAY_T
//! @brief 新しいインスタンス配列を指定した、インスタンスの型、配列の要素の数で作成します
#define MIX_NEW_ARRAY_T( T, count ) new( Mix::Memory::SECTION_USER, __FILEW__, __LINE__ ) T[count]
//! @def MIX_ALIGNED_NEW_ARRAY_T
//! @brief 新しいインスタンス配列を指定した、アライメント、インスタンスの型、配列の要素の数で作成します
#define MIX_ALIGNED_NEW_ARRAY_T( align, T, count ) new( Mix::Memory::SECTION_USER, align, __FILEW__, __LINE__ ) T[count]

/// @cond _INTERNAL
#ifdef _DEBUG
	#define MIX_DELETE_ARRAY_T_MEM_CHECK if( real == NULL ) { MIX_ERROR( L"管理外のメモリを解放しようとしました。 \"%s\"(%u)", __FILEW__, __LINE__ ); *( ( int* )0x0 ) = 0x0; }
#else //_DEBUG
	#define MIX_DELETE_ARRAY_T_MEM_CHECK
#endif //_DEBUG
/// @endcond

//! @def MIX_DELETE_ARRAY_T
//! @brief MIX_NEW_T によって作成されたインスタンス配列を削除します
#define MIX_DELETE_ARRAY_T( T, ptr ) \
	if( ptr != NULL ) \
	{ \
		UInt32* temp = ( UInt32* )ptr - 1; \
		void* real = NULL; \
		UInt32 count; \
		 \
		if( *temp == 0x4D474D47 ) \
		{ \
			real = ptr; \
			count = 0; \
		} \
		else if( *( temp - 1 ) == 0x4D474D47 ) \
		{ \
			real = temp; \
			count = *temp; \
		} \
		else if( *( temp - 2 ) == 0x4D474D47 ) \
		{ \
			real = ( temp - 1 ); \
			count = *( temp - 1 ); \
		} \
		 \
		MIX_DELETE_ARRAY_T_MEM_CHECK \
		 \
		if( count > 0 ) \
		{ \
			UInt32 i; \
			 \
			for( i = 0; i < count; i++ ) \
			{ \
				( ptr )[i].~T(); \
			} \
		} \
		 \
		Mix::Memory::Free( real, __FILEW__, __LINE__ ); \
		 \
		ptr = NULL; \
	}

//! @def MIX_DELETE_PTR_ARRAY_T
//! @brief MIX_NEW_ARRAY_T または MIX_ALIGNED_NEW_ARRAY_T によって作成されたインスタンスのポインタ配列を削除します
#define MIX_DELETE_PTR_ARRAY_T( ptr ) \
	if( ptr != NULL ) \
	{ \
		Mix::Memory::Free( ptr, __FILEW__, __LINE__ ); \
		ptr = NULL; \
	}

//! @}

//! @name 標準のメモリ管理を使用した、インスタンスの作成、削除
//! @{

//! @def MIX_NEW
//! @brief 新しいインスタンスを作成します
#define MIX_NEW new

//! @def MIX_DELETE
//! @brief MIX_NEW によって作成されたインスタンスを削除します
#define MIX_DELETE( x ) \
	if( x != NULL ) \
	{ \
		delete x; \
		x = NULL; \
	}

//! @def MIX_DELETE_ARRAY
//! @brief MIX_NEW によって作成されたインスタンス配列を削除します
#define MIX_DELETE_ARRAY( x ) \
	if( x != NULL ) \
	{ \
		delete [] x; \
		x = NULL; \
	}

//! @def MIX_DELETE_THIS
//! @brief MIX_NEW によって作成された自身のインスタンスを削除します
#define MIX_DELETE_THIS( x ) delete x

//! @}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// インクルード
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#include "Mix/String.h"
#include "Mix/Point.h"
#include "Mix/Rectangle.h"
#include "Mix/RectangleF.h"
#include "Mix/Vector2.h"
#include "Mix/Vector3.h"
#include "Mix/Vector4.h"
#include "Mix/Quaternion.h"
#include "Mix/Matrix3x3.h"
#include "Mix/Matrix4x4.h"

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 名前空間の定義 2
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

//! @namespace Mix::IO
//! @brief 入出力
namespace Mix{ namespace IO{

	class IManager;
	class IStream;
	class IReader;
	class IWriter;

	//! @enum SEEK_METHOD
	//! @brief シーク方式列挙定数
	enum SEEK_METHOD
	{
		SEEK_METHOD_BEGIN	= 0,	//!< ファイルの先頭からシーク
		SEEK_METHOD_CURRENT	= 1,	//!< ファイル現在位置からシーク
		SEEK_METHOD_END		= 2,	//!< ファイルの終端シーク
	};

	//! @enum SPECIAL_DIRECTORY_TYPE
	//! @brief 特殊ディレクトリタイプ列挙定数
	enum SPECIAL_DIRECTORY_TYPE
	{
		SPDIR_APPDATA		= 1,	//!< アプリケーションデータ
		SPDIR_DESKTOP		= 2,	//!< デスクトップ
		SPDIR_MYDOCUMENT	= 3,	//!< マイドキュメント
	};

	//! @brief マネージャのポインタを取得します
	//! @return マネージャを表す Mix::IO::IManager インターフェースのポインタを返します
	_MIX_DLL_API Mix::IO::IManager* GetManagerPtr( void );
	//! @brief マネージャを取得します
	//! @param[out] ppManager マネージャを表す Mix::IO::IManager インターフェースのポインタのアドレス
	//! @return 成功した場合は True を返します
	//! @note 取得したマネージャは参照カウンタを +1 します。
	_MIX_DLL_API Boolean GetManager( Mix::IO::IManager** ppManager );

	//! @brief 絶対パスかどうかを確認します
	//! @param[in] pPath 確認するパス
	//! @return 絶対パスの場合は True を返します
	_MIX_DLL_API Boolean IsAbsolutePath( const wchar_t* pPath );
	//! @brief 相対パスかどうかを確認します
	//! @param[in] pPath 確認するパス
	//! @return 相対パスの場合は True を返します
	_MIX_DLL_API Boolean IsRelativePath( const wchar_t* pPath );
	//! @brief パスを結合します
	//! @param[in] pBaseDirPath 結合する１つ目のディレクトリパス
	//! @param[in] bCnvBase pBaseDirPath に相対パスが指定され場合に、カレントディレクトリからの絶対パスに変換する場合は True
	//! @param[in] pRelPath 結合する２つ目のディレクトリ、もしくわファイルパス
	//! @param[out] outPath 結合されたパス
	//! @return 成功した場合は True を返します
	_MIX_DLL_API Boolean CombinePath( const wchar_t* pBaseDirPath, Boolean bCnvBase, const wchar_t* pRelPath, Mix::StringW& outPath );

	//! @brief 特殊ディレクトリの名前を取得します
	//! @param[in] type 特殊ディレクトリのタイプを表す Mix::SPECIAL_DIRECTORY_TYPE 列挙定数
	//! @param[out] dirPath 特殊ディレクトリのパスを格納する Mix::String クラス
	//! @return 成功した場合は True を返します
	_MIX_DLL_API Boolean GetSpecialDirectoryPath( Mix::IO::SPECIAL_DIRECTORY_TYPE type, Mix::String& dirPath );
}}

//! @namespace Mix::HID
//! @brief ヒューマンインターフェースデバイス
namespace Mix{ namespace HID{

	class IManager;
	class IKeyboard;
	class IMouse;
	class IGamepad;

	//! @enum KEY
	//! @brief キーコード列挙定数
	enum KEY
	{
		KEY_F1			= 1,	//!< F1
		KEY_F2			= 2,	//!< F2 
		KEY_F3			= 3,	//!< F3
		KEY_F4			= 4,	//!< F4
		KEY_F5			= 5,	//!< F5
		KEY_F6			= 6,	//!< F6
		KEY_F7			= 7,	//!< F7
		KEY_F8			= 8,	//!< F8
		KEY_F9			= 9,	//!< F9
		KEY_F10			= 10,	//!< F10
		KEY_F11			= 11,	//!< F11
		KEY_F12			= 12,	//!< F12

		KEY_0			= 13,	//!< 0
		KEY_1			= 14,	//!< 1
		KEY_2			= 15,	//!< 2
		KEY_3			= 16,	//!< 3
		KEY_4			= 17,	//!< 4
		KEY_5			= 18,	//!< 5
		KEY_6			= 19,	//!< 6
		KEY_7			= 20,	//!< 7
		KEY_8			= 21,	//!< 8
		KEY_9			= 22,	//!< 9

		KEY_NP0			= 23,	//!< NUMPAD 0
		KEY_NP1			= 24,	//!< NUMPAD 1
		KEY_NP2			= 25,	//!< NUMPAD 2
		KEY_NP3			= 26,	//!< NUMPAD 3
		KEY_NP4			= 27,	//!< NUMPAD 4
		KEY_NP5			= 28,	//!< NUMPAD 5
		KEY_NP6			= 29,	//!< NUMPAD 6
		KEY_NP7			= 30,	//!< NUMPAD 7
		KEY_NP8			= 31,	//!< NUMPAD 8
		KEY_NP9			= 32,	//!< NUMPAD 9

		KEY_A			= 33,	//!< A
		KEY_B			= 34,	//!< B
		KEY_C			= 35,	//!< C
		KEY_D			= 36,	//!< D
		KEY_E			= 37,	//!< E
		KEY_F			= 38,	//!< F
		KEY_G			= 39,	//!< G
		KEY_H			= 40,	//!< H
		KEY_I			= 41,	//!< I
		KEY_J			= 42,	//!< J
		KEY_K			= 43,	//!< K
		KEY_L			= 44,	//!< L
		KEY_M			= 45,	//!< M
		KEY_N			= 46,	//!< N
		KEY_O			= 47,	//!< O
		KEY_P			= 48,	//!< P
		KEY_Q			= 49,	//!< Q
		KEY_R			= 50,	//!< R
		KEY_S			= 51,	//!< S
		KEY_T			= 52,	//!< T
		KEY_U			= 53,	//!< U
		KEY_V			= 54,	//!< V
		KEY_W			= 55,	//!< W
		KEY_X			= 56,	//!< X
		KEY_Y			= 57,	//!< Y
		KEY_Z			= 58,	//!< Z

		KEY_UP			= 59,	//!< ↑
		KEY_DOWN		= 60,	//!< ↓
		KEY_LEFT		= 61,	//!< ←
		KEY_RIGHT		= 62,	//!< →

		KEY_ESCAPE		= 63,	//!< ESC
		KEY_TAB			= 64,	//!< TAB
		KEY_BACKSPACE	= 65,	//!< BACKSPACE
		KEY_DELETE		= 66,	//!< DEL
		KEY_SPACE		= 67,	//!< SPACE
		KEY_RETURN		= 68,	//!< RETURN( ENTER )
		KEY_SHIFT		= 69,	//!< SHIFT
		KEY_LSHIFT		= 70,	//!< 左SHIFT
		KEY_RSHIFT		= 71,	//!< 右SHIFT
		KEY_CTRL		= 72,	//!< CTRL
		KEY_LCTRL		= 73,	//!< 左CTRL
		KEY_RCTRL		= 74,	//!< 右CTRL
		KEY_ALT			= 75,	//!< ALT
		KEY_LALT		= 76,	//!< 左ALT
		KEY_RALT		= 77,	//!< 右ALT

		KEY_MAX			= 78,	//!< キーの最大数
	};

	//! @enum GAMEPAD_API
	//! @brief ゲームパッド API 列挙定数
	enum GAMEPAD_API
	{
		GAMEPAD_UNKNOWN		= 0,	//!< 不明
		GAMEPAD_XINPUT		= 1,	//!< XInput
		GAMEPAD_DIRECTINPUT	= 2,	//!< DirectInput
	};

	//! @enum GAMEPAD_CONSTANT
	//! @brief ゲームパッド定数列挙定数
	enum GAMEPAD_CONSTANT
	{
		GAMEPAD_TRIGGER_RESOLUTION	= 255,		//!< トリガーの解像度
		GAMEPAD_STICK_RESOLUTION	= 32767,	//!< スティックの解像度

		GAMEPAD_LEFT				= 0,		//!< 左
		GAMEPAD_RIGHT				= 1,		//!< 右
	};

	//! @enum GAMEPAD_PORT
	//! @brief ゲームパッドポート列挙定数
	enum GAMEPAD_PORT
	{
		GAMEPAD_XI_A		= 0,	//!< XInputゲームパッドA
		GAMEPAD_XI_B		= 1,	//!< XInputゲームパッドB
		GAMEPAD_XI_C		= 2,	//!< XInputゲームパッドC
		GAMEPAD_XI_D		= 3,	//!< XInputゲームパッドD

		GAMEPAD_DI_A		= 4,	//!< DirectInputゲームパッドA
		GAMEPAD_DI_B		= 5,	//!< DirectInputゲームパッドB
		GAMEPAD_DI_C		= 6,	//!< DirectInputゲームパッドC
		GAMEPAD_DI_D		= 7,	//!< DirectInputゲームパッドD

		GAMEPAD_PORT_MAX	= 8,	//!< ゲームポートの最大数
	};

	//! @enum GAMEPAD_BUTTON
	//! @brief ゲームパッドボタン列挙定数
	enum GAMEPAD_BUTTON
	{
		GAMEPAD_POV_UP			= 0,	//!< POV( 上 )
		GAMEPAD_POV_DOWN		= 1,	//!< POV( 下 )
		GAMEPAD_POV_LEFT		= 2,	//!< POV( 左 )
		GAMEPAD_POV_RIGHT		= 3,	//!< POV( 右 )
		GAMEPAD_START			= 4,	//!< スタート
		GAMEPAD_BACK			= 5,	//!< バック
		GAMEPAD_STICK_LEFT		= 6,	//!< スティック( 左 )
		GAMEPAD_STICK_RIGHT		= 7,	//!< スティック( 右 )
		GAMEPAD_SHOULDER_LEFT	= 8,	//!< ショルダー( 左 )
		GAMEPAD_SHOULDER_RIGHT	= 9,	//!< ショルダー( 右 )
		GAMEPAD_A				= 10,	//!< A
		GAMEPAD_B				= 11,	//!< B
		GAMEPAD_X				= 12,	//!< X
		GAMEPAD_Y				= 13,	//!< Y

		GAMEPAD_BUTTON_MAX		= 14,	//!< ボタンの最大数
	};

	//! @enum SWITCH_STATE
	//! @brief スイッチステート列挙定数
	enum SWITCH_STATE
	{
		PRESSED			= 0x00000001,		//!< キーもしくわ、ボタンが押された
		RELEASED		= 0x00000002,		//!< キーもしくわ、ボタンが離された
		DOWN			= 0x00000004,		//!< キーもしくわ、ボタンが押されている
	};

	//! @brief マネージャのポインタを取得します
	//! @return マネージャを表す Mix::HID::IManager インターフェースのポインタを返します
	_MIX_DLL_API Mix::HID::IManager* GetManagerPtr( void );
	//! @brief マネージャを取得します
	//! @param[out] ppManager マネージャを表す Mix::HID::IManager インターフェースのポインタのアドレス
	//! @return 成功した場合は True を返します
	//! @note 取得したマネージャは参照カウンタを +1 します。
	_MIX_DLL_API Boolean GetManager( Mix::HID::IManager** ppManager );
}}

//! @namespace Mix::Parallel
//! @brief パラレル
namespace Mix{ namespace Parallel{

	class IManager;

	//! @enum DEBUG_ID
	//! @brief デバッグ用識別子 列挙定数
	enum DEBUG_ID
	{
		DEBUG_DYNAMICS_COLLISION_DISPATCHER = 0,	//!< ダイナミクス : コリジョンディスパッチャー
		DEBUG_DYNAMICS_JOINT_SOLVER			= 1,	//!< ダイナミクス : ジョイントソルバー

		DEBUG_USER							= 2,	//!< ユーザー定義
	};
	
	//! @fn void Function( UInt32 threadNum, UInt32 threadIndex, void* pData )
	//! @brief ファンクション
	//! @param threadNum ファンクションを実行するスレッドの数
	//! @param threadIndex ファンクションを実行しているスレッドのインデックス ( 0 <= threadIndex < threadNum )
	//! @param pData ファンクションの実行時 ( Mix::Parallel::IManager::ExecuteFunction ) に渡したデータのポインタ
	typedef void __stdcall Function( UInt32 threadNum, UInt32 threadIndex, void* pData );

	//! @typedef FunctionPtr
	//! @brief Mix::Parallel::Function のポインタ
	typedef Function* FunctionPtr;

	//! @struct WORK
	//! @brief ワーク構造体
	struct WORK
	{
		UInt32 threadIndex;					//!< スレッドのインデックス
		HANDLE hWakeup;						//!< ウェイクアップ用同期オブジェクトのハンドル
		Mix::Parallel::FunctionPtr pFunc;	//!< 実行するファンクションのポインタ
		void* pData;						//!< ファンクションに渡すデータのポインタ
		UInt32 debugID;						//!< デバッグ用識別子 ( Mix::Parallel::DEBUG_ID )
	};

	//! @struct DEBUG_FUNC_INFO
	//! @brief デバッグ : ファンクション情報構造体
	struct DEBUG_FUNC_INFO
	{
		UInt32 id;				//!< 識別子 ( Mix::Parallel::DEBUG_ID )
		Float32 startTime;		//!< ファンクションを開始した時間 ( 秒単位 )
		Float32 elapsedTime;	//!< ファンクションの実行にかかった時間 ( 秒単位 )
	};

	//! @struct DEBUG_THREAD_INFO
	//! @brief デバッグ : スレッド情報構造体
	struct DEBUG_THREAD_INFO
	{
		Float32 elapsedTime;				//!< スレッドで実行されたファンクションの合計時間

		UInt32 funcCount;					//!< スレッドで実行されたファンクションの数
		const DEBUG_FUNC_INFO* funcInfos;	//!< スレッドで実行されたファンクションの情報配列
	};

	//! @brief マネージャのポインタを取得します
	//! @return マネージャを表す Mix::Parallel::IManager インターフェースのポインタを返します
	_MIX_DLL_API Mix::Parallel::IManager* GetManagerPtr( void );
	//! @brief マネージャを取得します
	//! @param[out] ppManager マネージャを表す Mix::Parallel::IManager インターフェースのポインタのアドレス
	//! @return 成功した場合は True を返します
	//! @note 取得したマネージャは参照カウンタを +1 します。
	_MIX_DLL_API Boolean GetManager( Mix::Parallel::IManager** ppManager );

}}

//! @namespace Mix::Geometry
//! @brief ジオメトリ
namespace Mix{ namespace Geometry{

	class AABB;
	class Frustum;
	class OBB;
	class Plane;
	class Sphere;

	//! @brief 平面から点までの距離を求めます
	//! @param[in] p 点を表す Mix::Vector3 クラス
	//! @param[in] plane Mix::Geometry::Plane クラス
	//! @return 平面から点までの距離
	_MIX_DLL_API Float32 DistancePointPlane( const Mix::Vector3& p, const Mix::Geometry::Plane& plane );

	//! @brief 球から点への最接近点を求めます
	//! @param[in] p 判定する点を表す Mix::Vector3 クラス
	//! @param[in] sphere 判定する球を表す Mix::Geometry::Sphere クラス
	//! @param[out] q 最接近点を表す Mix::Vector3 クラス
	_MIX_DLL_API void ClosestPointSphere( const Mix::Vector3& p, const Mix::Geometry::Sphere& sphere, Mix::Vector3& q );
	//! @brief 平面から点への最接近点を求めます
	//! @param[in] p 判定する点を表す Mix::Vector3 クラス
	//! @param[in] plane 判定する平面を表す Mix::Geometry::Plane クラス
	//! @param[out] q 最接近点を表す Mix::Vector3 クラス
	_MIX_DLL_API void ClosestPointPlane( const Mix::Vector3& p, const Mix::Geometry::Plane& plane, Mix::Vector3& q );
	//! @brief OBBから点への最接近点を求めます
	//! @param[in] p 判定する点を表す Mix::Vector3 クラス
	//! @param[in] obb 判定するOBBを表す Mix::Geometry::OBB クラス
	//! @param[out] q 最接近点を表す Mix::Vector3 クラス
	_MIX_DLL_API void ClosestPointOBB( const Mix::Vector3& p, const Mix::Geometry::OBB& obb, Mix::Vector3& q );
	//! @brief AABBと点の最接近点を求めます
	//! @param[in] p 判定する点を表す Mix::Vector3 クラス
	//! @param[in] aabb 判定するAABBを表す Mix::Geometry::AABB クラス
	//! @param[out] q 最接近点を表す Mix::Vector3 クラス
	_MIX_DLL_API void ClosestPointAABB( const Mix::Vector3& p, const Mix::Geometry::AABB& aabb, Mix::Vector3& q );

	//! @brief 点が時計回りの三角形abcの内側にあるかどうかを判定します
	//! @param[in] p 判定する点を表す Mix::Vector3 クラス
	//! @param[in] a 判定する三角形の点1を表す Mix::Vector3 クラス
	//! @param[in] b 判定する三角形の点2を表す Mix::Vector3 クラス
	//! @param[in] c 判定する三角形の3点を表す Mix::Vector3 クラス
	//! @return 点が三角形の内側にある場合は True を返します
	_MIX_DLL_API Boolean PointInTriangle( const Mix::Vector3& p, const Mix::Vector3& a, const Mix::Vector3& b, const Mix::Vector3& c );

	//! @brief AABBと点の交差しているかどうかを判定します
	//! @param[in] p 判定する点を表す Mix::Vector3 クラス
	//! @param[in] aabb 判定するAABBを表す Mix::Geometry::AABB クラス
	//! @return 交差している場合は True を返します
	_MIX_DLL_API Boolean IntersectPointAABB( const Mix::Vector3& p, const Mix::Geometry::AABB& aabb );
	//! @brief 球同士が交差しているかどうかを判定します
	//! @param[in] sphere1 判定する球を表す Mix::Geometry::Sphere クラス
	//! @param[in] sphere2 判定する球を表す Mix::Geometry::Sphere クラス
	//! @param[out] pDist 球同士の中心の距離
	//! @return 交差している場合は True を返します
	_MIX_DLL_API Boolean IntersectSphereSphere( const Mix::Geometry::Sphere& sphere1, const Mix::Geometry::Sphere& sphere2, Float32* pDist = NULL );
	//! @brief 球と平面が交差しているかどうかを判定します
	//! @param[in] sphere 判定する球を表す Mix::Geometry::Sphere クラス
	//! @param[in] plane 判定する平面を表す Mix::Geometry::Plane クラス
	//! @param[out] pDist 平面から球の中心までの距離
	//! @return 交差している場合は True を返します
	_MIX_DLL_API Boolean IntersectSpherePlane( const Mix::Geometry::Sphere& sphere, const Mix::Geometry::Plane& plane, Float32* pDist = NULL );
	//! @brief 球とOBBが交差しているかどうかを判定します
	//! @param[in] sphere 判定する球を表す Mix::Geometry::Sphere クラス
	//! @param[in] obb 判定するOBBを表す Mix::Geometry::OBB クラス
	//! @param[out] pPos 球の中心に対するOBB上の最接近点を表す Mix::Vector3 クラスのポインタ
	//! @return 交差している場合は True を返します
	_MIX_DLL_API Boolean IntersectSphereOBB( const Mix::Geometry::Sphere& sphere, const Mix::Geometry::OBB& obb, Mix::Vector3* pPos = NULL );
	//! @brief 球とAABBが交差しているかどうかを判定します
	//! @param[in] sphere 判定する球を表す Mix::Geometry::Sphere クラス
	//! @param[in] aabb 判定するAABBを表す Mix::Geometry::AABB クラス
	//! @param[out] pPos 球の中心に対するAABB上の最接近点を表す Mix::Vector3 クラスのポインタ
	//! @return 交差している場合は True を返します
	_MIX_DLL_API Boolean IntersectSphereAABB( const Mix::Geometry::Sphere& sphere, const Mix::Geometry::AABB& aabb, Mix::Vector3* pPos = NULL );

	//! @brief 平面と平面が交差しているかどうかを判定します
	//! @param[in] plane1 判定する平面を表す Mix::Geometry::Plane クラス
	//! @param[in] plane2 判定する平面を表す Mix::Geometry::Plane クラス
	//! @param[out] pPos 交差直線上の点の位置を表す Mix::Vector3 クラスのポインタ
	//! @param[out] pDir 交差直線上の方向を表す Mix::Vector3 クラスのポインタ
	//! @return 交差している場合は True を返します
	_MIX_DLL_API Boolean IntersectPlanePlane( const Mix::Geometry::Plane& plane1, const Mix::Geometry::Plane& plane2, Mix::Vector3* pPos = NULL, Mix::Vector3* pDir = NULL );
	//! @brief 平面とOBBが交差しているかどうかを判定します
	//! @param[in] plane 判定する平面を表す Mix::Geometry::Plane クラス
	//! @param[in] obb 判定するOBBを表す Mix::Geometry::OBB クラス
	//! @return 交差している場合は True を返します
	_MIX_DLL_API Boolean IntersectPlaneOBB( const Mix::Geometry::Plane& plane, const Mix::Geometry::OBB& obb );
	//! @brief 平面とAABBが交差しているかどうかを判定します
	//! @param[in] plane 判定する平面を表す Mix::Geometry::Plane クラス
	//! @param[in] aabb 判定するAABBを表す Mix::Geometry::AABB クラス
	//! @return 交差している場合は True を返します
	_MIX_DLL_API Boolean IntersectPlaneAABB( const Mix::Geometry::Plane& plane, const Mix::Geometry::AABB& aabb );

	//! @brief OBB同士が交差しているかどうかを判定します
	//! @param[in] obb1 判定するOBBを表す Mix::Geometry::OBB クラス
	//! @param[in] obb2 判定するOBBを表す Mix::Geometry::OBB クラス
	//! @return 交差している場合は True を返します
	_MIX_DLL_API Boolean IntersectOBBOBB( const Mix::Geometry::OBB& obb1, const Mix::Geometry::OBB& obb2 );

	//! @brief AABB同士が交差しているかどうかを判定します
	//! @param[in] aabb1 判定するAABBを表す Mix::Geometry::AABB クラス
	//! @param[in] aabb2 判定するAABBを表す Mix::Geometry::AABB クラス
	//! @return 交差している場合は True を返します
	_MIX_DLL_API Boolean IntersectAABBAABB( const Mix::Geometry::AABB& aabb1, const Mix::Geometry::AABB& aabb2 );

	//! @brief 光線と球が交差しているかどうかを判定します
	//! @param[in] rayPos 光線を発している位置を表す Mix::Vector3 クラス
	//! @param[in] rayDir 光線のベクトルを表す rayDir
	//! @param[in] sphere 判定する球を表す Mix::Geometry::Sphere クラス
	//! @param[out] pDist 光線を発している位置から交差している位置までの距離
	//! @param[out] pPos 光線が交差している位置を表す Mix::Vector3 クラスのポインタ
	//! @return 交差している場合は True を返します
	_MIX_DLL_API Boolean IntersectRaySphere( const Mix::Vector3& rayPos, const Mix::Vector3& rayDir, const Mix::Geometry::Sphere& sphere, Float32* pDist = NULL, Mix::Vector3* pPos = NULL );
	//! @brief 光線と平面が交差しているかどうかを判定します
	//! @param[in] rayPos 光線を発している位置を表す Mix::Vector3 クラス
	//! @param[in] rayDir 光線のベクトルを表す rayDir
	//! @param[in] plane 判定する平面を表す Mix::Geometry::Plane クラス
	//! @param[out] pDist 光線を発している位置から交差している位置までの距離
	//! @param[out] pPos 光線が交差している位置を表す Mix::Vector3 クラスのポインタ
	//! @return 交差している場合は True を返します
	_MIX_DLL_API Boolean IntersectRayPlane( const Mix::Vector3& rayPos, const Mix::Vector3& rayDir, const Mix::Geometry::Plane& plane, Float32* pDist = NULL, Mix::Vector3* pPos = NULL );
	//! @brief 光線とOBBが交差しているかどうかを判定します
	//! @param[in] rayPos 光線を発している位置を表す Mix::Vector3 クラス
	//! @param[in] rayDir 光線のベクトルを表す rayDir
	//! @param[in] obb 判定するOBBを表す Mix::Geometry::OBB クラス
	//! @return 交差している場合は True を返します
	_MIX_DLL_API Boolean IntersectRayOBB( const Mix::Vector3& rayPos, const Mix::Vector3& rayDir, const Mix::Geometry::OBB& obb );
	//! @brief 光線とAABBが交差しているかどうかを判定します
	//! @param[in] rayPos 光線を発している位置を表す Mix::Vector3 クラス
	//! @param[in] rayDir 光線のベクトルを表す rayDir
	//! @param[in] aabb 判定するAABBを表す Mix::Geometry::AABB クラス
	//! @param[out] pDist 光線を発している位置から交差している位置までの距離
	//! @param[out] pPos 光線が交差している位置を表す Mix::Vector3 クラスのポインタ
	//! @return 交差している場合は True を返します
	_MIX_DLL_API Boolean IntersectRayAABB( const Mix::Vector3& rayPos, const Mix::Vector3& rayDir, const Mix::Geometry::AABB& aabb, Float32* pDist = NULL, Mix::Vector3* pPos = NULL );

	//! @brief 線分と球が交差しているかどうかを判定します
	//! @param[in] p1 線分の端の点を表す Mix::Vector3 クラス
	//! @param[in] p2 線分の端の点を表す Mix::Vector3 クラス
	//! @param[in] sphere 判定する球を表す Mix::Geometry::Sphere クラス
	//! @return 交差している場合は True を返します
	_MIX_DLL_API Boolean IntersectSegmentSphere( const Mix::Vector3& p1, const Mix::Vector3& p2, const Mix::Geometry::Sphere& sphere );
	//! @brief 線分と平面が交差しているかどうかを判定します
	//! @param[in] p1 線分の端の点1を表す Mix::Vector3 クラス
	//! @param[in] p2 線分の端の点2を表す Mix::Vector3 クラス
	//! @param[in] plane 判定する平面を表す Mix::Geometry::Plane クラス
	//! @param[out] pDist 光線を発している位置から交差している位置までの距離
	//! @param[out] pPos 光線が交差している位置を表す Mix::Vector3 クラスのポインタ
	//! @return 交差している場合は True を返します
	_MIX_DLL_API Boolean IntersectSegmentPlane( const Mix::Vector3& p1, const Mix::Vector3& p2, const Mix::Geometry::Plane& plane, Float32* pDist = NULL, Mix::Vector3* pPos = NULL );
	//! @brief 線分とOBBが交差しているかどうかを判定します
	//! @param[in] p1 線分の端の点1を表す Mix::Vector3 クラス
	//! @param[in] p2 線分の端の点2を表す Mix::Vector3 クラス
	//! @param[in] obb 判定するOBBを表す Mix::Geometry::OBB クラス
	//! @param[out] pDist 光線を発している位置から交差している位置までの距離
	//! @param[out] pPos 光線が交差している位置を表す Mix::Vector3 クラスのポインタ
	//! @return 交差している場合は True を返します
	//! @note 未実装
	_MIX_DLL_API Boolean IntersectSegmentOBB( const Mix::Vector3& p1, const Mix::Vector3& p2, const Mix::Geometry::OBB& obb, Float32* pDist = NULL, Mix::Vector3* pPos = NULL );
	//! @brief 線分とAABBが交差しているかどうかを判定します
	//! @param[in] p1 線分の端の点1を表す Mix::Vector3 クラス
	//! @param[in] p2 線分の端の点2を表す Mix::Vector3 クラス
	//! @param[in] aabb 判定するOBBを表す Mix::Geometry::AABB クラス
	//! @return 交差している場合は True を返します
	_MIX_DLL_API Boolean IntersectSegmentAABB( const Mix::Vector3& p1, const Mix::Vector3& p2, const Mix::Geometry::AABB& aabb );

}}
//! @namespace Mix::Graphics
//! @brief グラフィックス
namespace Mix{ namespace Graphics{

	class IManager;
	class IDevice;
	class IDeviceObject;
	class IVertexLayout;
	class IHullShader;
	class IDomainShader;
	class IGeometryShader;
	class IVertexShader;
	class IPixelShader;
	class IShaderConstant;
	class IVertexBuffer;
	class IIndexBuffer;
	class ITexture;
	class IQuery;

	//! @enum SHADER_MODEL
	//! @brief シェーダーモデル列挙定数
	enum SHADER_MODEL
	{
		SHADER_MODEL_3	= 0,	//!< シェーダーモデル 3.0( DirectX9 )
		SHADER_MODEL_4	= 1,	//!< シェーダーモデル 4.0( DirectX10 )
		SHADER_MODEL_5	= 2,	//!< シェーダーモデル 5.0( DirectX11 )
	};

	//! @enum VERTEX_ELEMENT_SEMANTIC
	//! @brief バーテックスエレメントセマンティック列挙定数
	enum VERTEX_ELEMENT_SEMANTIC
	{
		VLS_POSITION		= 0,	//!< 座標( Float32[4] )
		VLS_BLENDWEIGHT		= 1,	//!< ブレンドの重み( Float32 )
		VLS_BLENDINDICES	= 2,	//!< ブレンドインデックス( UInt32[n] )
		VLS_NORMAL			= 3,	//!< 法線( Float32[4] )
		VLS_PSIZE			= 4,	//!< ポイントサイズ( Float32[n] )
		VLS_TEXTURE			= 5,	//!< テクスチャ座標( Float32[4] )
		VLS_TANGENT			= 6,	//!< 接線( Float32[4] )
		VLS_BINORMAL		= 7,	//!< 従法線( Float32[4] )
		VLS_COLOR			= 8,	//!< カラー( Float32[4] )
	};

	//! @enum VERTEX_ELEMENT_FORMAT
	//! @brief バーテックスエレメントフォーマット列挙定数
	enum VERTEX_ELEMENT_FORMAT
	{
		VLF_FLOAT32_1	= 0,	//!< 1成分、32ビット浮動小数点
		VLF_FLOAT32_2	= 1,	//!< 2成分、32ビット浮動小数点
		VLF_FLOAT32_3	= 2,	//!< 3成分、32ビット浮動小数点
		VLF_FLOAT32_4	= 3,	//!< 4成分、32ビット浮動小数点
		VLF_UINT8_4		= 4,	//!< 4成分、8ビット符号なし整数
		VLF_INT16_2		= 5,	//!< 2成分、16ビット符号あり整数
		VLF_INT16_4		= 6,	//!< 4成分、16ビット符号あり整数
		VLF_UINT8_4N	= 7,	//!< 4成分、8ビット符号なし整数( 正規化 )
		VLF_INT16_2N	= 8,	//!< 2成分、16ビット符号あり整数( 正規化 )
		VLF_INT16_4N	= 9,	//!< 4成分、16ビット符号あり整数( 正規化 )
		VLF_UINT16_2N	= 10,	//!< 2成分、16ビット符号なし整数( 正規化 )
		VLF_UINT16_4N	= 11,	//!< 4成分、16ビット符号なし整数( 正規化 )
		VLF_FLOAT16_2	= 12,	//!< 2成分、16ビット浮動小数点
		VLF_FLOAT16_4	= 13,	//!< 4成分、16ビット浮動小数点
	};

	//! @enum SHADER_TARGET
	//! @brief シェーダーターゲット列挙定数
	enum SHADER_TARGET
	{
		VS_3_0	= 0,	//!< バーテックスシェーダー 3.0
		PS_3_0	= 1,	//!< ピクセルシェーダー 3.0

		CS_4_0	= 2,	//!< コンピュートシェーダー 4.0
		GS_4_0	= 3,	//!< ジオメトリシェーダー 4.0
		VS_4_0	= 4,	//!< バーテックスシェーダー 4.0
		PS_4_0	= 5,	//!< ピクセルシェーダー 4.0

		CS_4_1	= 6,	//!< コンピュートシェーダー 4.1
		GS_4_1	= 7,	//!< ジオメトリシェーダー 4.1
		VS_4_1	= 8,	//!< バーテックスシェーダー 4.1
		PS_4_1	= 9,	//!< ピクセルシェーダー 4.1

		CS_5_0	= 10,	//!< コンピュートシェーダー 5.0
		DS_5_0	= 11,	//!< ドメインシェーダー 5.0
		GS_5_0	= 12,	//!< ジオメトリシェーダー 5.0
		HS_5_0	= 13,	//!< ハルシェーダー 5.0
		VS_5_0	= 14,	//!< バーテックスシェーダー 5.0
		PS_5_0	= 15,	//!< ピクセルシェーダー 5.0
	};

	//! @struct SHADER_MACRO
	//! @brief シェーダーマクロ構造体
	struct SHADER_MACRO
	{
		const char* pNameA;	//!< 名前
		const char* pDefA;	//!< 定義
	};

	//! @enum FILL_TYPE
	//! @brief 描画タイプ列挙定数
	enum FILL_TYPE
	{
		FILL_WIREFRAME	= 0,	//!< ワイヤーフレーム
		FILL_SOLID		= 1,	//!< ソリッド
	};

	//! @enum CULL_TYPE
	//! @brief カリングタイプ列挙定数
	enum CULL_TYPE
	{
		CULL_NONE	= 0,	//!< 全ての三角形を描画します
		CULL_FRONT	= 1,	//!< 前向きの三角形を描画しません
		CULL_BACK	= 2,	//!< 後ろ向きの三角形を描画しません
	};

	//! @enum BLEND_TYPE
	//! @brief ブレンドタイプ列挙定数
	enum BLEND_TYPE
	{
		BLEND_COPY		= 0,	//!< コピー
		BLEND_NORMAL	= 1,	//!< 通常
		BLEND_ADD		= 2,	//!< 加算
		BLEND_SUB		= 3,	//!< 減算
		BLEND_MUL		= 4,	//!< 乗算
		BLEND_SCREEN	= 5,	//!< スクリーン
	};

	//! @enum ZFUNC_TYPE
	//! @brief Zファンクション列挙定数
	enum ZFUNC_TYPE
	{
		ZFUNC_ALWAYS		= 0,	//!< 常に成功する
		ZFUNC_NEVER			= 1,	//!< 常に失敗する
		ZFUNC_LESS			= 2,	//!< 新しいピクセルが現在のピクセルより小さい時に応じる
		ZFUNC_EQUAL			= 3,	//!< 新しいピクセルが現在のピクセルと等しい時に応じる
		ZFUNC_LESSEQUAL		= 4,	//!< 新しいピクセル値が、現在のピクセル値以下のときに応じる
		ZFUNC_GREATER		= 5,	//!< 新しいピクセル値が、現在のピクセル値より大きいときに応じる
		ZFUNC_NOTEQUAL		= 6,	//!< 新しいピクセル値が、現在のピクセル値と等しくないときに応じる
		ZFUNC_GREATEREQUAL	= 7,	//!< 新しいピクセル値が、現在のピクセル値以上のときに応じる
	};

	//! @enum TEXTURE_FILTER_TYPE
	//! @brief テクスチャフィルタタイプ列挙定数
	enum TEXTURE_FILTER_TYPE
	{
		TEXTURE_FILTER_POINT		= 0,	//!< ポイントフィルタ
		TEXTURE_FILTER_LINEAR		= 1,	//!< リニアフィルタ( 線形補間 )
		TEXTURE_FILTER_ANISOTROPIC	= 2,	//!< アニソトロピックフィルタ( 異方性補間 )
	};

	//! @enum TEXTURE_ADDRESS_TYPE
	//! @brief テクスチャー座標の解決手法列挙定数
	enum TEXTURE_ADDRESS_TYPE
	{
		TEXTURE_ADDRESS_WRAP		= 0,	//!< 整数区切りごとにテクスチャーを繰り返します
		TEXTURE_ADDRESS_CLAMP	= 1,	//!< 整数区切りごとにテクスチャーを反転させます
	};

	//! @enum CUBEMAP_FACE
	//! @brief キューブマップのフェイス列挙定数
	enum CUBEMAP_FACE
	{
		CUBEMAP_FACE_POSITIVE_X = 0,	//!< 正方向のＸ面
		CUBEMAP_FACE_NEGATIVE_X = 1,	//!< 負方向のＸ面
		CUBEMAP_FACE_POSITIVE_Y = 2,	//!< 正方向のＹ面
		CUBEMAP_FACE_NEGATIVE_Y = 3,	//!< 負方向のＹ面
		CUBEMAP_FACE_POSITIVE_Z = 4,	//!< 正方向のＺ面
		CUBEMAP_FACE_NEGATIVE_Z = 5,	//!< 負方向のＺ面
	};

	//! @enum FORMAT
	//! @brief フォーマット列挙定数
	enum FORMAT
	{
		FMT_UNKNOWN			= 0,	//!< 不明なフォーマット

		FMT_D16				= 1,	//!< 1成分、デプスチャンネル16ビットフォーマット
		FMT_D32				= 2,	//!< 1成分、デプスチャンネル32ビットフォーマット
		FMT_D24S8			= 3,	//!< 2成分、デプスチャンネル24ビット ステンシルチャンネル8ビットフォーマット

		FMT_R8G8B8A8		= 4,	//!< 4成分、32ビットフォーマット
		FMT_A8				= 5,	//!< 1成分、8ビットフォーマット
		FMT_R16F			= 6,	//!< 1成分、16ビット浮動小数点フォーマット
		FMT_R32F			= 7,	//!< 1成分、32ビット浮動小数点フォーマット
		FMT_R16G16F			= 8,	//!< 2成分、16ビット浮動小数点フォーマット
		FMT_R32G32F			= 9,	//!< 2成分、32ビット浮動小数点フォーマット
		FMT_R16G16B16A16F	= 10,	//!< 4成分、64ビット浮動小数点フォーマット
		FMT_R32G32B32A32F	= 11,	//!< 4成分、128ビット浮動小数点フォーマット

		FMT_BC1				= 12,	//!< BC1 ( DXT1 ) 圧縮フォーマット
		FMT_BC2				= 13,	//!< BC2 ( DXT3 ) 圧縮フォーマット
		FMT_BC3				= 14,	//!< BC3 ( DXT5 ) 圧縮フォーマット
	};

	//! @enum INDEX_FORMAT
	//! @brief インデックスフォーマット列挙定数
	enum INDEX_FORMAT
	{
		INDEX_USHORT	= 0,	//!< 16Bitインデックスバッファ
		INDEX_UINT		= 1,	//!< 32Bitインデックスバッファ
	};

	//! @enum QUERY_FORMAT
	//! @brief クエリフォーマット列挙定数
	enum QUERY_FORMAT
	{
		QUERY_EVENT		= 0,	//!< イベント
		QUERY_OCCLUSION	= 1,	//!< オクルージョン
	};

	//! @enum PRIMITIVE_TYPE
	//! @brief プリミティブタイプ列挙定数
	enum PRIMITIVE_TYPE
	{
		PRIMITIVE_POINTLIST		= 0,	//!< ポイントリスト
		PRIMITIVE_LINELIST		= 1,	//!< ラインリスト
		PRIMITIVE_LINESTRIP		= 2,	//!< ラインストリップ
		PRIMITIVE_TRIANGLELIST	= 3,	//!< トライアングルリスト
		PRIMITIVE_TRIANGLESTRIP	= 4,	//!< トライアングルストリップ
	};

	//! @enum COLOR_WRITE_MASK
	//! @brief カラー書き込みマスク列挙定数
	enum COLOR_WRITE_MASK
	{
		COLOR_WRITE_RGBA	= 0,	//!< 全て書き込む
		COLOR_WRITE_RGB		= 1,	//!< RGBのみ書き込む
		COLOR_WRITE_A		= 2,	//!< アルファのみ書き込む
	};

	//! @struct VERTEX_ELEMENT
	//! @brief バーテックスエレメント構造体
	struct VERTEX_ELEMENT
	{
		UInt32 semanticType;	//!< セマンティックタイプ( Mix::Graphics::VERTEX_ELEMENT_SEMANTIC )
		UInt32 semanticIndex;	//!< セマンティックインデックス
		UInt32 format;			//!< フォーマット( Mix::Graphics::VERTEX_ELEMENT_FORMAT )
		UInt32 offset;			//!< オフセット
	};

	//! @struct RASTERIZER_DESC
	//! @brief ラスタライザステート構造体
	struct RASTERIZER_DESC
	{
		Mix::Graphics::FILL_TYPE fillMode;	//!< フィルモード
		Mix::Graphics::CULL_TYPE cullMode;	//!< カリングモード
		Boolean bScissoring;				//!< シザリングを有効にする場合は True
	};

	//! @struct DEPTH_DESC
	//! @brief デプスステート構造体
	struct DEPTH_DESC
	{
		Boolean bTest;					//!< Zテストを有効にする場合は True
		Boolean bWrite;					//!< Z値の書き込みを有効にする場合は True
		Mix::Graphics::ZFUNC_TYPE func;	//!< Zテストに使用するファンクション
	};

	//! @struct BLEND_DESC
	//! @brief ブレンドステート構造体
	struct BLEND_DESC
	{
		Mix::Graphics::BLEND_TYPE type;					//!< タイプ
		Mix::Graphics::COLOR_WRITE_MASK colorWriteMask;	//!< カラーの書き込みマスクを表す Mix::Graphics::COLOR_WRITE_MASK 列挙定数
	};

	//! @brief マネージャのポインタを取得します
	//! @return マネージャを表す Mix::Graphics::IManager インターフェースのポインタを返します
	_MIX_DLL_API Mix::Graphics::IManager* GetManagerPtr( void );
	//! @brief マネージャを取得します
	//! @param[out] ppManager マネージャを表す Mix::Graphics::IManager インターフェースのポインタのアドレス
	//! @return 成功した場合は True を返します
	//! @note 取得したマネージャは参照カウンタを +1 します。
	_MIX_DLL_API Boolean GetManager( Mix::Graphics::IManager** ppManager );
}}

//! @namespace Mix::Graphics::Utility
//! @brief グラフィックス ( ユーティリティ )
namespace Mix{ namespace Graphics{ namespace Utility{

	class ITargetTextureChain;
	class IFont;
	class IPerspectiveRenderer;
	class ICanvasRenderer;

	//! @enum STRING_FLAGS
	//! @brief 文字列フラグ列挙定数
	enum STRING_FLAGS
	{
		SF_HCENTER		= 0x00000001,	//!< 水平方向でセンタリング
		SF_VCENTER		= 0x00000002,	//!< 垂直方向でセンタリング
		SF_WORDBREAK	= 0x00000004,	//!< 矩形からはみ出した場合は改行
	};

	//! @brief シェーダーをコンパイルします
	//! @param[in] pFilePath ファイルパス
	//! @param[in] pMacros マクロ配列( NULL指定可能 )
	//! @param[in] pFuncName ファンクションの名前
	//! @param[in] target ターゲットを表す Mix::Graphics::SHADER_TARGET 列挙定数
	//! @param[out] ppBuffer コンパイルされたシェーダを格納する Mix::Memory::IBuffer インターフェースのポインタのアドレス
	//! @return 成功した場合は True を返します
	//! @note マクロを指定する場合は末尾に SHADER_MACRO( pName = NULL, pDef = NULL ) を追加しておいてください。
	_MIX_DLL_API Boolean CompileShaderFromFile(	const wchar_t* pFilePath,
												Mix::Graphics::SHADER_MACRO* pMacros,
												const char* pFuncName,
												Mix::Graphics::SHADER_TARGET target,
												Mix::Memory::IBuffer** ppBuffer );

	//! @brief シェーダーをコンパイルします
	//! @param[in] pFilePath ファイルパス
	//! @param[in] pSrc コンパイルするソースのポインタ( ANSI )
	//! @param[in] srcSize コンパイルするソースのサイズ
	//! @param[in] pMacros マクロ配列( NULL指定可能 )
	//! @param[in] pFuncName ファンクションの名前
	//! @param[in] target ターゲットを表す Mix::Graphics::SHADER_TARGET 列挙定数
	//! @param[out] ppBuffer コンパイルされたシェーダを格納する Mix::Memory::IBuffer インターフェースのポインタのアドレス
	//! @return 成功した場合は True を返します
	//! @note マクロを指定する場合は末尾に SHADER_MACRO( pName = NULL, pDef = NULL ) を追加しておいてください。
	_MIX_DLL_API Boolean CompileShaderFromMemory(	const wchar_t* pFilePath,
													const void* pSrc, UInt32 srcSize,
													Mix::Graphics::SHADER_MACRO* pMacros,
													const char* pFuncName,
													Mix::Graphics::SHADER_TARGET target,
													Mix::Memory::IBuffer** ppBuffer );

	//! @brief 指定したフォントと文字列で描画した場合のサイズを計測します
	//! @param[in] pFont フォントを表す Mix::Graphics::Utility::IFont インターフェースのポインタ
	//! @param[in] pStr 文字列
	//! @return 計測したサイズを表す Mix::Point クラスを返します
	_MIX_DLL_API Mix::Point MeasureString( Mix::Graphics::Utility::IFont* pFont, const wchar_t* pStr );

}}}

//! @namespace Mix::Sound
//! @brief サウンド
namespace Mix{ namespace Sound{

	class IManager;
	class IDevice;
	class IController;
	class IEmitter;
	class IListener;

	//! @brief マネージャのポインタを取得します
	//! @return マネージャを表す Mix::Sound::IManager インターフェースのポインタを返します
	_MIX_DLL_API Mix::Sound::IManager* GetManagerPtr( void );
	//! @brief マネージャを取得します
	//! @param[out] ppManager マネージャを表す Mix::Sound::IManager インターフェースのポインタのアドレス
	//! @return 成功した場合は True を返します
	//! @note 取得したマネージャは参照カウンタを +1 します。
	_MIX_DLL_API Boolean GetManager( Mix::Sound::IManager** ppManager );

}}

//! @namespace Mix::Dynamics
//! @brief ダイナミクス
namespace Mix{ namespace Dynamics{

	class IManager;
	class IShape;
	class ISphereShape;
	class IBoxShape;
	class IConeShape;
	class ICapsuleShape;
	class ICylinderShape;
	class IConvexHullShape;
	class ICompoundShape;
	class IJoint;
	class IPointJoint;
	class IHingeJoint;
	class ISliderJoint;
	class IDofJoint;
	class IBallJoint;
	class IWorld;
	class IObject;
	class IObjectListener;
	class IObjectDragger;
	class ISimpleObject;
	class IStaticPlane;
	class IStaticMesh;
	class IRigidBody;
	class ISensor;
	class IKinematicCharacter;
	class IVehicle;
	class IVehicleWheel;

	//! @enum AXIS_TYPE
	//! @brief 軸タイプ列挙定数
	enum AXIS_TYPE
	{
		AXIS_X = 0,	//!< X軸
		AXIS_Y = 1,	//!< Y軸
		AXIS_Z = 2,	//!< Z軸
	};

	//! @enum OBJECT_FILTER_FLAG
	//! @brief オブジェクトフィルターフラグ列挙定数
	enum OBJECT_FILTER_FLAG
	{
		OF_DEFAULT			= 0x0001,	//!< デフォルト
		OF_STATIC			= 0x0002,	//!< スタティック
		OF_KINEMATIC		= 0x0004,	//!< キネマティック
		OF_DEBRIS			= 0x0008,	//!< デブリ
		OF_SENSOR			= 0x0010,	//!< センサー
		OF_CHARACTER		= 0x0020,	//!< キャラクター

		//! @brief 全て
		OF_ALL				= ( OF_DEFAULT | OF_STATIC | OF_KINEMATIC | OF_DEBRIS | OF_SENSOR | OF_CHARACTER ),

		//! @brief デフォルトフィルターマスク
		OF_DEFAULT_MASK		= ( OF_DEFAULT | OF_STATIC | OF_KINEMATIC | OF_SENSOR ),
		//! @brief スタティックフィルターマスク
		OF_STATIC_MASK		= ( OF_DEFAULT | OF_KINEMATIC | OF_DEBRIS | OF_SENSOR | OF_CHARACTER ),
		//! @brief キネマティックフィルターマスク
		OF_KINEMATIC_MASK	= ( OF_DEFAULT | OF_SENSOR ),
		//! @brief デブリフィルターマスク
		OF_DEBRIS_MASK		= ( OF_STATIC ),
		//! @brief センサーフィルターマスク
		OF_SENSOR_MASK		= ( OF_DEFAULT | OF_STATIC | OF_KINEMATIC ),
		//! @brief キャラクターフィルターマスク
		OF_CHARACTER_MASK	= ( OF_STATIC | OF_CHARACTER ),
	};

	//! @enum DEBUG_DRAW_FLAG
	//! @brief デバッグ描画のフラグ列挙定数
	enum DEBUG_DRAW_FLAG
	{
		DD_WIREFRAME	= 0x00000001,	//!< ワイヤーフレーム(リジッドボディ、センサー、キネマティックキャラクター)
		DD_AXIS			= 0x00000002,	//!< 軸( リジッドボディ )
		DD_JOINT_FRAME	= 0x00000004,	//!< ジョイントのフレーム
		DD_JOINT_LIMIT	= 0x00000008,	//!< ジョイントのリミット
	};

	//! @enum DEBUG_DRAW_COLOR_TYPE
	//! @brief デバッグ描画のカラータイプ列挙定数
	enum DEBUG_DRAW_COLOR_TYPE
	{
		DDC_RIGIDBODY_AROUSAL		= 0,	//!< リジッドボディ : 常に活動状態
		DDC_RIGIDBODY_ACTIVE		= 1,	//!< リジッドボディ : 活動状態
		DDC_RIGIDBODY_SLEEPY		= 2,	//!< リジッドボディ : 休止になる手前の状態
		DDC_RIGIDBODY_REST			= 3,	//!< リジッドボディ : 休止状態
		DDC_RIGIDBODY_DISABLE		= 4,	//!< リジッドボディ : 無効( シミュレーションは行われていない )

		DDC_SENSOR					= 5,	//!< センサー

		DDC_KINEMATIC_CHARACTER		= 6,	//!< キネマティックキャラクター

		DDC_JOINT_FRAME				= 7,	//!< ジョイント : フレーム
		DDC_JOINT_LIMIT				= 8,	//!< ジョイント : リミット
	};

	//! @struct WORLD_CONFIG
	//! @brief ワールド設定構造体
	struct WORLD_CONFIG
	{
		Boolean bParallelCollisionDispatcher;	//!< コリジョンのディスパッチを並列で処理する場合は True
		Boolean bParallelJointSolver;			//!< ジョイントソルバーを並列で処理する場合は True

		UInt32 numContactSolverIterations;	//!< LCP ソルバーの反復数 ( 4 〜 20 )
		Float32 allowedCcdPenetration;		//!< スウィープテストをした際にめり込んでいると判断する深度

		UInt32 persistentManifoldPoolSize;	//!< マニフォールドのメモリプールのサイズ
		UInt32 collisionAlgorithmPoolSize;	//!< コリジョンアルゴリズムのメモリプールのサイズ

		//! @brief コンストラクタ
		WORLD_CONFIG( void )
		{
			bParallelCollisionDispatcher = True;
			bParallelJointSolver = False;

			numContactSolverIterations = 10;
			allowedCcdPenetration = 0.04f;

			persistentManifoldPoolSize = 4096;
			collisionAlgorithmPoolSize = 4096;
		}
	};

	//! @struct MATERIAL
	//! @brief マテリアル構造体
	struct MATERIAL
	{
		UInt32 id;				//!< 識別子
		UInt32 attr;			//!< 属性
		Float32 friction;		//!< 摩擦係数
		Float32 restitution;	//!< 反発係数

		//! @brief コンストラクタ
		MATERIAL( void )
		{
			id = 0;
			attr = 0;
			friction = 0.5f;
			restitution = 0.0f;
		}

		//! @brief コンストラクタ
		//! @param[in] _id 識別子
		//! @param[in] _attr 属性
		MATERIAL( UInt32 _id, UInt32 _attr )
		{
			id = _id;
			attr = _attr;
			friction = 0.5f;
			restitution = 0.0f;
		}

		//! @brief コンストラクタ
		//! @param[in] _id 識別子
		//! @param[in] _attr 属性
		//! @param[in] _friction 摩擦係数
		//! @param[in] _restitution 反発係数
		MATERIAL( UInt32 _id, UInt32 _attr, Float32 _friction, Float32 _restitution )
		{
			id = _id;
			attr = _attr;
			friction = _friction;
			restitution = _restitution;
		}
	};

	//! @struct MESH
	//! @brief メッシュ構造体
	struct MESH
	{
		//! @brief 頂点数
		UInt32 vertexCount;

		//! @brief 頂点リスト
		const Mix::Vector3* vertices;

		//! @brief ポリゴン数
		UInt32 polygonCount;

		//! @brief ポリゴンのインデックスリスト
		//! @note
		//! 頂点の参照用インデックス配列になります。<br>
		//! ポリゴン数 * 3 の要素を持つ配列を用意する必要があります( 三角形で指定する必要があることを意味します )。
		const UInt32* polygonIndices;
	};

	//! @struct MANIFOLD_MESH
	//! @brief マニフォールドメッシュ構造体
	struct MANIFOLD_MESH
	{
		//! @brief パートインデックス
		//! @note スタティックメッシュを作成する際に渡した Mix::Dynamics::MESH 配列のインデックスになります
		UInt32 partIndex;

		//! @brief ポリゴンのインデックス
		UInt32 polygonIndex;
	};

	//! @struct MANIFOLD_POINT
	//! @brief マニフォールドポイント構造体
	struct MANIFOLD_POINT
	{
		Mix::Vector3 localPositionA;				//!< 自身 : 接触位置のローカル座標
		Mix::Vector3 localPositionB;				//!< 相手 : 接触位置のローカル座標

		Mix::Vector3 worldPositionA;				//!< 自身 : 接触位置のワールド座標
		Mix::Vector3 worldPositionB;				//!< 相手 : 接触位置のワールド座標

		Mix::Vector3 worldNormalB;					//!< 相手 : 接触位置のワールド法線

		Mix::Dynamics::MATERIAL materialA;			//!< 自身 : 接触位置のマテリアル
		Mix::Dynamics::MATERIAL materialB;			//!< 相手 : 接触位置のマテリアル

		Mix::Dynamics::MANIFOLD_MESH meshA;			//!< 自身 : メッシュ
		Mix::Dynamics::MANIFOLD_MESH meshB;			//!< 相手 : メッシュ

		Float32 penetrationB;						//!< めり込んでいる距離

		Float32 impulse;							//!< 撃力

		Float32 combinedFriction;					//!< 合成した摩擦係数
		Float32 combinedRestitution;				//!< 合成した反発係数
	};

	//! @struct MANIFOLD
	//! @brief マニフォールド構造体
	struct MANIFOLD
	{
		Mix::Dynamics::IObject* pObjectB;				//!< 接触しているオブジェクトを表す Mix::Dynamics::IObject インターフェースのポインタ

		UInt32 pointCount;								//!< ポイントの数
		const Mix::Dynamics::MANIFOLD_POINT* points;	//!< ポイントリスト
	};

	//! @struct TEST_LOCAL_RESULT
	//! @brief ローカルの交差判定結果構造体
	struct TEST_LOCAL_RESULT
	{
		Mix::Vector3 pos;						//!< 接触座標
		Mix::Vector3 normal;					//!< 接触している座標の法線
	};

	//! @struct VEHICLE_WHEEL_DESC
	//! @brief ビハイクルホイール構造体
	struct VEHICLE_WHEEL_DESC
	{
		Boolean bFront;					//!< フロントの場合は True
		Mix::Vector3 direction;			//!< 下方向
		Mix::Vector3 axis;				//!< シャフトの軸
		Mix::Vector3 connectionPoint;	//!< 接続位置
		Float32 tireRadius;				//!< タイヤの半径
		Float32 suspensionRestLength;	//!< サスペンションの長さ
	};

	//! @struct DEBUG_WORLD_PROFILE
	//! @brief デバッグ : ワールドプロファイル
	struct DEBUG_WORLD_PROFILE
	{
		Float32 ssElapsedTime;	//!< シミュレーションにかかった時間( 秒単位 )
		Float32 cpElapsedTime;	//!< 接触情報の収集にかっかた時間( 秒単位 )
	};

	//! @brief マネージャのポインタを取得します
	//! @return マネージャを表す Mix::Dynamics::IManager インターフェースのポインタを返します
	_MIX_DLL_API Mix::Dynamics::IManager* GetManagerPtr( void );
	//! @brief マネージャを取得します
	//! @param[out] ppManager マネージャを表す Mix::Dynamics::IManager インターフェースのポインタのアドレス
	//! @return 成功した場合は True を返します
	//! @note 取得したマネージャは参照カウンタを +1 します。
	_MIX_DLL_API Boolean GetManager( Mix::Dynamics::IManager** ppManager );

	//! @brief レイとオブジェクトの交差判定を行います
	//! @param[in] rayFrom レイの始点を表す Mix::Vector3 クラス
	//! @param[in] rayTo レイの終点を表す Mix::Vector3 クラス
	//! @param[in] pReceiveObject 交差判定を行うオブジェクトを表す Mix::Dynamics::IObject インターフェースのポインタ
	//! @param[out] result 交差判定結果を表す Mix::Dynamics::TEST_LOCAL_RESULT 構造体
	//! @return 交差している場合は True を返します
	_MIX_DLL_API Boolean TestRay(	const Mix::Vector3& rayFrom,
									const Mix::Vector3& rayTo,
									const Mix::Dynamics::IObject* pReceiveObject,
									Mix::Dynamics::TEST_LOCAL_RESULT& result );

	//! @brief スィープとオブジェクトの交差判定を行います
	//! @param[in] pCastShape スィープを作成するシェイプを表す Mix::Dynamics::IShape インターフェースのポインタ
	//! @param[in] castShapeFromPos スィープの始点の位置を表す Mix::Vector3 クラス
	//! @param[in] castShapeToPos スィープの終点の位置を表す Mix::Vector3 クラス
	//! @param[in] pReceiveObject 交差判定を行うオブジェクトを表す Mix::Dynamics::IObject インターフェースのポインタ
	//! @param[out] result 交差判定結果を表す Mix::Dynamics::TEST_LOCAL_RESULT 構造体
	//! @return 交差している場合は True を返します
	_MIX_DLL_API Boolean TestSweep(	const Mix::Dynamics::IShape* pCastShape,
									const Mix::Vector3& castShapeFromPos,
									const Mix::Vector3& castShapeToPos,
									const Mix::Dynamics::IObject* pReceiveObject,
									Mix::Dynamics::TEST_LOCAL_RESULT& result );

	//! @brief スィープとオブジェクトの交差判定を行います
	//! @param[in] pCastShape スィープを作成するシェイプを表す Mix::Dynamics::IShape インターフェースのポインタ
	//! @param[in] castShapeFromRot スィープの始点の回転を表す Mix::Vector3 クラス
	//! @param[in] castShapeFromPos スィープの始点の位置を表す Mix::Vector3 クラス
	//! @param[in] castShapeToRot スィープの終点の回転を表す Mix::Vector3 クラス
	//! @param[in] castShapeToPos スィープの終点の位置を表す Mix::Vector3 クラス
	//! @param[in] pReceiveObject 交差判定を行うオブジェクトを表す Mix::Dynamics::IObject インターフェースのポインタ
	//! @param[out] result 交差判定結果を表す Mix::Dynamics::TEST_LOCAL_RESULT 構造体
	//! @return 交差している場合は True を返します
	_MIX_DLL_API Boolean TestSweep(	const Mix::Dynamics::IShape* pCastShape,
									const Mix::Quaternion& castShapeFromRot, const Mix::Vector3& castShapeFromPos,
									const Mix::Quaternion& castShapeToRot, const Mix::Vector3& castShapeToPos,
									const Mix::Dynamics::IObject* pReceiveObject,
									Mix::Dynamics::TEST_LOCAL_RESULT& result );
}}

//! @namespace Mix::Scene
//! @brief シーン
namespace Mix{ namespace Scene{

	class IManager;

	class IEffectPackage;

	class IMaterial;
	class IDefaultMaterial;

	class IMotionMixer;
	class IMotionController;
	class IMotionListener;
	class IMotionState;
	class IMotion;

	class IDynamicsObject;
	class IContactListener;
	class ICollider;
	class ISimpleCollider;
	class ILibertyCollider;
	class IActorCollider;
	class ITerrainCollider;
	class ISensor;
	class ISimpleSensor;
	class IActorSensor;
	class IKinematicCharacter;
	class ISimpleKinematicCharacter;
	class IActorKinematicCharacter;

	class IRenderer;
	class IRendererObject;
	class IEntity;

	class ICamera;
	class IUniversalCamera;
	class IViewCamera;

	class IHemisphereLight;
	class IDirectionalLight;
	class ISpotLight;
	class IPointLight;

	class ISkyDome;
	class IParticle;
	class ILeavingParticle;
	class IScatterParticle;
	class IParticleSystem;
	class IDefaultParticleSystem;
	class IBillboardParticleSystem;
	class IParticleGenerator;
	class IParticleProcessor;
	class IActorModel;
	class IActorListener;
	class IActorNode;
	class IActorConstraint;
	class IActorDynamicsDirector;
	class ITerrainModel;
	class IFlowerPackage;
	class IPlanter;

	class IWaterPool;
	class IWaterPoolContext;

	class IFloor;
	class IGhost;

	class ILightShaftsCaster;
	class IAtmosphereScatter;
	class IDynamicsWorld;

	//! @struct MOTION_HANDLE
	//! @brief モーションハンドル構造体
	struct _MIX_DLL_API MOTION_HANDLE
	{
		const void* ref0;	//!< 変更禁止！
		const void* ref1;	//!< 変更禁止！

		//! @brief コンストラクタ
		MOTION_HANDLE( void );
		//! @brief コンストラクタ
		//! @param[in] value 常に0
		MOTION_HANDLE( Int32 value );
		//! @brief コンストラクタ
		//! @param[in] handle ハンドル
		MOTION_HANDLE( const MOTION_HANDLE& handle );
		//! @brief 使用禁止
		MOTION_HANDLE( const void* r0, const void* r1 );

		//! @brief ハンドルを NULL にします
		//! @param[in] value 常に NULL
		//! @return NULL にしたハンドルを返します
		MOTION_HANDLE& operator = ( Int32 value );

		//! @brief コピーします
		//! @param[in] handle コピー元のハンドル
		//! @return コピーしたハンドルを返します
		MOTION_HANDLE& operator = ( const MOTION_HANDLE& handle );

		//! @brief NULLかどうかを確認します
		//! @param[in] value 常に NULL
		//! @return NULL だった場合は True を返します
		Boolean operator == ( Int32 value ) const;
		//! @brief NULLかどうかを確認します
		//! @param[in] value 常に NULL
		//! @return NULL だった場合は True を返します
		Boolean operator != ( Int32 value ) const;

		//! @brief 同じかハンドルかどうかを確認します
		//! @param[in] handle 比較するハンドル
		//! @return 同じハンドルの場合は True を返します
		Boolean operator == ( const MOTION_HANDLE& handle ) const;
		//! @brief 違うハンドルかどうかを確認します
		//! @param[in] handle 比較するハンドル
		//! @return 違うハンドルの場合は True を返します
		Boolean operator != ( const MOTION_HANDLE& handle ) const;

		//! @brief 検索用
		bool operator < ( const MOTION_HANDLE& handle ) const;
	};

	//! @enum MOTION_CONSTANT
	//! @brief モーションの列挙定数
	enum MOTION_CONSTANT
	{
		MOTION_INFINITE_LOOP	= 0xFFFFFFFF,	//!< 無限ループ
	};

	//! @enum MOTION_RT_FLAG
	//! @brief モーションのルートトランスフォームフラグ列挙定数
	enum MOTION_RT_FLAG
	{
		MOTION_RT_ROTATION		= 0x00000001,	//!< 回転
		MOTION_RT_TRANSLATION	= 0x00000002,	//!< 移動
	};

	//! @enum MOTION_CONDITION_FLAG
	//! @brief モーション状態フラグ列挙定数
	enum MOTION_CONDITION_FLAG
	{
		//! @brief 待機中
		//! @note コマンドキューの最後にある状態
		MOTION_COND_WATING		= 0x00000001,

		//! @brief 再生されている
		//! @note このフラグ単体で設定されている場合( MOTION_COND_CURRENT は設定されていない )は、<br>
		//! プレビアスモーション( トランジション終了後に停止状態になる )になります
		MOTION_COND_ACTIVE		= 0x00000002,

		//! @brief カレントモーションである
		//! @note MOTION_COND_ACTIVE とペアで設定されます
		MOTION_COND_CURRENT		= 0x00000004,

		//! @brief すべてのフラグ
		MOTION_COND_ALL			= ( MOTION_COND_WATING | MOTION_COND_CURRENT ),

		//! @brief カレントモーションとして再生されている
		MOTION_COND_CUR_ACTIVE	= ( MOTION_COND_CURRENT | MOTION_COND_ACTIVE ),
	};

	//! @enum MOTION_COMMAND_EXECUTE_TYPE
	//! @brief モーションコマンンド実行タイプ列挙定数
	enum MOTION_COMMAND_EXECUTE_TYPE
	{
		//! @brief 遅延実行( 通常 )
		//! @note 待機中のコマンドが全て消化されるまで実行されません
		MOTION_CE_DEFAULT	= 0,

		//! @brief 早期実行
		//! @note 現在待機中のコマンドを破棄し、トランジションの終了が確認され次第、実行します
		MOTION_CE_EARLY		= 1,

		//! @brief 強制実行
		//! @note 現在待機中のコマンドを破棄し、トランジションを中断してから、実行します
		MOTION_CE_FORCE		= 2,
	};

	//! @enum MOTION_COMMAND_FLAG
	//! @brief モーションコマンドフラグ列挙定数
	enum MOTION_COMMAND_FLAG
	{
		//! @brief モーションを活性化します
		MOTION_CF_ACTIVATE				= 0x00000001,

		//! @brief フレーム( MOTION_COMMAND::frame )を有効にします
		MOTION_CF_FRAME					= 0x00000002,
		//! @brief ループ( MOTION_COMMAND::loopCount )を有効にします
		MOTION_CF_LOOP					= 0x00000004,
		//! @brief トランジション( MOTION_COMMAND::transitionTimeLength )を有効にします
		MOTION_CF_TRANSITION			= 0x00000008,

		//! @brief フレームを引き継ぎます
		//! @note MOTION_CF_ACTIVATE MOTION_CF_FRAME が指定されている必要があります
		MOTION_CF_FRAME_INHERIT			= 0x00000010,
		//! @brief ループを引き継ぎます
		//! @note MOTION_CF_ACTIVATE MOTION_CF_LOOP が指定されている必要があります
		MOTION_CF_LOOP_INHERIT			= 0x00000020,
		//! @brief トランジションを引き継ぎます
		//! @note MOTION_CF_ACTIVATE MOTION_CF_TRANSITION が指定されている必要があります
		MOTION_CF_TRANSITION_INHERIT	= 0x00000040,

		//! @brief フレーム、ループ、トランジションの全てを設定します
		MOTION_CF_SET_ALL				= ( MOTION_CF_FRAME | MOTION_CF_LOOP | MOTION_CF_TRANSITION ),

		//! @brief フレーム、ループ、トランジションを全て引き継ぎます
		//! @note 再生しようとしているモーションが、現在、もしくわ直前のモーションと同じだった場合に、引き継がれます。
		MOTION_CF_INHERIT				= ( MOTION_CF_FRAME_INHERIT | MOTION_CF_LOOP_INHERIT | MOTION_CF_TRANSITION_INHERIT ),

		//! @brief フレーム、ループ、トランジションを設定して再生
		MOTION_CF_PLAY					= ( MOTION_CF_ACTIVATE | MOTION_CF_SET_ALL ),
		//! @brief フレーム、ループ、トランジションを設定して再生( 引継ぎ有り )
		MOTION_CF_PLAY_INHERIT			= ( MOTION_CF_ACTIVATE | MOTION_CF_SET_ALL | MOTION_CF_INHERIT ),

		//! @brief トランジションを設定して停止
		MOTION_CF_STOP					= ( MOTION_CF_TRANSITION ),
	};

	//! @struct MOTION_COMMAND
	//! @brief モーションコマンド構造体
	struct MOTION_COMMAND
	{
		//! @brief フラグ( Mix::Scene::MOTION_COMMAND_FLAG 列挙定数の組み合わせ )
		UInt32 flags;

		//! @brief ハンドル
		//! @note flags に Mix::Scene::MOTION_CF_ACTIVATE が設定されている場合のみ有効
		MOTION_HANDLE handle;

		//! @brief フレーム
		//! @note flags に Mix::Scene::MOTION_CF_FRAME が設定されている場合のみ有効
		Float32 frame;

		//! @brief ループ数( Mix::Scene::MOTION_INFINITE_LOOP で無限ループ )
		//! @note flags に Mix::Scene::MOTION_CF_LOOP が設定されている場合のみ有効
		UInt32 loopCount;

		//! @brief トランジションに要する時間の長さ( 秒単位 )
		//! @note flags に Mix::Scene::MOTION_CF_TRANSITION が設定されている場合のみ有効
		Float32 transitionTimeLength;
	};

	//! @struct MOTION_ENTRY_DESC
	//! @brief モーションエントリー構造体
	struct MOTION_ENTRY_DESC
	{
		Float32 startFrame;	//!< 開始フレーム
		Float32 endFrame;	//!< 終了フレーム
		Boolean bAlways;	//!< 開始フレームから終了フレームの間の場合は常に呼び出す

		void* userPtr;		//!< ユーザーポインタ
		Int32 userIndex;	//!< ユーザーインデックス
	};

	//! @enum RENDERER_CAPABILITY_FLAG
	//! @brief レンダラー能力フラグ列挙定数
	enum RENDERER_CAPABILITY_FLAG
	{
		RCAP_WIDGET				=	0x00000001,	//!< ウィジェット( パーティクル、プランター )
		RCAP_DYNAMICS			=	0x00000002,	//!< ダイナミクスワールド
		RCAP_ATMOSPHERE			=	0x00000004,	//!< 大気
		RCAP_SHADOW_MAPPING		=	0x00000008,	//!< シャドウマッピング
		RCAP_AMBIENT_OCCLUSION	=	0x00000010,	//!< アンビエントオクルージョン
		RCAP_LUMINOSITY			=	0x00000020,	//!< 輝度による階調補正
		RCAP_BLOOM				=	0x00000040,	//!< ブルーム
		RCAP_LIGHT_SHAFTS		=	0x00000080,	//!< ライトシャフト
		RCAP_LENS_FLARE			=	0x00000100,	//!< レンズフレア
		RCAP_CHROMATISM			=	0x00000200,	//!< 色収差
		RCAP_DEPTH_OF_FIELD		=	0x00000400,	//!< 被写界深度

		//! @brief 全て
		RCAP_ALL			=	RCAP_WIDGET |
								RCAP_DYNAMICS |
								RCAP_ATMOSPHERE |
								RCAP_SHADOW_MAPPING |
								RCAP_AMBIENT_OCCLUSION |
								RCAP_LUMINOSITY |
								RCAP_BLOOM |
								RCAP_LIGHT_SHAFTS |
								RCAP_LENS_FLARE |
								RCAP_CHROMATISM |
								RCAP_DEPTH_OF_FIELD,
	};

	//! @enum RENDERER_SAMPLING_RESOLUTION
	//! @brief レンダラー : サンプリング解像度列挙定数
	enum RENDERER_SAMPLING_RESOLUTION
	{
		RSMPL_DEFAULT	= 0,	//!< デフォルト
		RSMPL_DOWN2X	= 1,	//!< スクリーンサイズの1/2
		RSMPL_DOWN4X	= 2,	//!< スクリーンサイズの1/4
	};

	//! @struct RENDERER_OCTREE_CONFIG
	//! @brief レンダラー : 八分木設定構造体
	struct RENDERER_OCTREE_CONFIG
	{
		//! @brief 有効範囲の最小
		//! @note 配置するオブジェクトを含む範囲を表します。
		Mix::Vector3 minAABB;
		//! @brief 有効範囲の最大
		//! @note 配置するオブジェクトを含む範囲を表します。
		Mix::Vector3 maxAABB;
		//! @brief 細分化レベル( 0〜7 )
		UInt32 subdivisionLevel;
	};

	//! @struct RENDERER_CONFIG
	//! @brief レンダラー設定構造体
	struct RENDERER_CONFIG
	{
		//! @brief 能力を表す Mix::Scene::RENDERER_CAPABILITY_FLAG 列挙定数の組み合わせ
		UInt32 caps;

		//! @brief 八分木の設定
		Mix::Scene::RENDERER_OCTREE_CONFIG octree;
		//! @brief ダイナミクスの設定
		Mix::Dynamics::WORLD_CONFIG dynamics;

		//! @brief コンストラクタ
		RENDERER_CONFIG( void )
		{
			caps = Mix::Scene::RCAP_ALL;

			octree.minAABB.Set( -500.0f, -500.0f, -500.0f );
			octree.maxAABB.Set( +500.0f, +500.0f, +500.0f );
			octree.subdivisionLevel = 4;

			dynamics.persistentManifoldPoolSize = 4096;
			dynamics.collisionAlgorithmPoolSize = 4096;
		}
	};

	//! @struct CAMERA_CONFIG
	//! @brief カメラ設定構造体
	struct CAMERA_CONFIG
	{
		//! @brief 能力を表す Mix::Scene::RENDERER_CAPABILITY_FLAG 列挙定数の組み合わせ
		//! @note
		//! 設定できる能力は以下のものに限定されます。<br>
		//! <br>
		//! RCAP_DYNAMICS<br>
		//! RCAP_AMBIENT_OCCLUSION<br>
		//! RCAP_SHADOW_MAPPING<br>
		//! RCAP_LUMINOSITY<br>
		//! RCAP_BLOOM<br>
		//! RCAP_LIGHT_SHAFTS<br>
		//! RCAP_LENS_FLARE<br>
		//! RCAP_CHROMATISM<br>
		//! RCAP_DEPTH_OF_FIELD<br>
		//! <br>
		//! また、ダイナミクス( RCAP_DYNAMICS ) はカメラを使用してオブジェクトのドラッグをするかどうかを指定するものであって、<br>
		//! ダイナミクス自体の ON、OFF をするもではありません。
		UInt32 caps;

		//! @brief ターゲットのサイズ
		//! @note 描画先のターゲットの解像度になります。
		Mix::Point targetSize;

		//! @brief 深度バッファのフォーマット
		Mix::Graphics::FORMAT depthBuffFormat;

		//! @brief カラーテクスチャフォーマット
		//! @note 使用できるフォーマットは「FMT_R8G8B8A8」「FMT_R16G16B16A16F」「FMT_R32G32B32A32F」 の３つになります。
		Mix::Graphics::FORMAT colorTexFormat;

		//! @brief 深度テクスチャフォーマット
		//! @note
		//! パーティクル、被写界深度、アンビエントオクルージョン などで使用されます。<br>
		//! 使用できるフォーマットは「FMT_R16F」「FMT_R32F」の２つになります。<br>
		//! <br>
		//! デバッグ時は、デバッグ描画を行えるようにするために以下のようにフォーマットを解釈します。<br>
		//! <br>
		//! 「FMT_R16F」→「FMT_R16G16B16A16F」<br>
		//! 「FMT_R32F」→「FMT_R32G32B32A32F」<br>
		Mix::Graphics::FORMAT depthTexFormat;

		//! @brief 屈折テクスチャフォーマット
		//! @note
		//! 使用できるフォーマットは「FMT_R16G16B16A16F」「FMT_R32G32B32A32F」の２つになります。<br>
		//! 色、深度を格納するため、カラーフォーマットと深度の精度を考慮にいれて設定してください。
		Mix::Graphics::FORMAT refractTexFormat;

		//! @brief アンビエントオクルージョンのサンプリング解像度
		//! @note Mix::Scene::RSMPL_DEFAULT を指定した場合は、スクリーンのサイズになります。
		Mix::Scene::RENDERER_SAMPLING_RESOLUTION aoSmplRes;

		//! @brief シャドウマッピングの深度テクスチャのフォーマット
		//! @note 使用できるフォーマットは「FMT_R16G16B16A16F」「FMT_R32G32B32A32F」の２つになります。<br>
		Mix::Graphics::FORMAT smDepthTexFormat;
		//! @brief シャドウマッピングの深度テクスチャの一辺のサイズ
		//! @note 256を下回る値を指定した場合は、256を指定したとみなします。
		UInt32 smDepthTexSize;
		//! @brief シャドウマッピングのサンプリング解像度
		//! @note Mix::Scene::RSMPL_DEFAULT を指定した場合は、スクリーンのサイズになります。
		Mix::Scene::RENDERER_SAMPLING_RESOLUTION smSmplRes;

		//! @brief 輝度テクスチャフォーマット
		//! @note
		//! 使用できるフォーマットは「FMT_R16F」「FMT_R32F」の２つになります。<br>
		//! <br>
		//! デバッグ時は、デバッグ描画を行えるようにするために以下のようにフォーマットを解釈します。<br>
		//! <br>
		//! 「FMT_R16F」→「FMT_R16G16B16A16F」<br>
		//! 「FMT_R32F」→「FMT_R32G32B32A32F」<br>
		Mix::Graphics::FORMAT lumTexFormat;

		//! @brief ブルームのオーバーフロー数
		//! @note 0を指定した場合は、1を指定したとみなします。
		UInt32 bloomOverflowNum;
		//! @brief ブルームのサンプリング解像度
		//! @note Mix::Scene::RSMPL_DEFAULT を指定した場合は Mix::Scene::RSMPL_DOWN2X を指定したと見なされます。
		Mix::Scene::RENDERER_SAMPLING_RESOLUTION bloomSmplRes;

		//! @brief レンズフレアのサンプリング解像度
		//! @note Mix::Scene::RSMPL_DEFAULT を指定した場合は、スクリーンのサイズになります。
		Mix::Scene::RENDERER_SAMPLING_RESOLUTION lfSmplRes;

		//! @brief 色収差のサンプリング解像度
		//! @note Mix::Scene::RSMPL_DEFAULT を指定した場合は、スクリーンのサイズになります。
		Mix::Scene::RENDERER_SAMPLING_RESOLUTION caSmplRes;

		//! @brief 被写界深度のサンプリング解像度
		//! @note Mix::Scene::RSMPL_DEFAULT を指定した場合は、スクリーンのサイズになります。
		Mix::Scene::RENDERER_SAMPLING_RESOLUTION dofSmplRes;

		//! @brief コンストラクタ
		CAMERA_CONFIG( void )
		{
			caps = Mix::Scene::RCAP_ALL;

			depthBuffFormat = Mix::Graphics::FMT_D24S8;

			colorTexFormat = Mix::Graphics::FMT_R16G16B16A16F;
			depthTexFormat = Mix::Graphics::FMT_R16F;
			refractTexFormat = Mix::Graphics::FMT_R16G16B16A16F;

			aoSmplRes = Mix::Scene::RSMPL_DOWN2X;

			smDepthTexFormat = Mix::Graphics::FMT_R16G16B16A16F;
			smDepthTexSize = 2048;
			smSmplRes = Mix::Scene::RSMPL_DOWN2X;

			lumTexFormat = Mix::Graphics::FMT_R16F;

			bloomOverflowNum = 1;
			bloomSmplRes = Mix::Scene::RSMPL_DOWN2X;

			lfSmplRes = Mix::Scene::RSMPL_DOWN2X;

			caSmplRes = Mix::Scene::RSMPL_DOWN2X;

			dofSmplRes = Mix::Scene::RSMPL_DOWN2X;
		}
	};

	//! @struct BRIGHT_PASS
	//! @brief ブライトパス構造体
	struct BRIGHT_PASS
	{
		Boolean bLumInf;	//!< 輝度の影響を受ける場合は True
		Float32 white;		//!< 白く表示される輝度の強さ( 0.0f〜正の無限大 )
		Float32 threshold;	//!< 高輝度部分を抽出する際の閾値( 0.0f〜正の無限大 )
		Float32 offset;		//!< 高輝度部分を抽出する際のオフセット( 0.0f〜正の無限大 )
	};

	//! @struct BLUR
	//! @brief ブラー構造体
	struct _MIX_DLL_API BLUR
	{
	public:
		//! @enum TYPE
		//! @brief タイプ列挙定数
		enum TYPE
		{
			T_NONE			= 0,	//!< 無し
			T_KS_3x3		= 1,	//!< 3x3
			T_KS_5x5		= 2,	//!< 5x5
			T_GAUSSIAN		= 3,	//!< ガウシアンブラー
			T_GAUSSIAN_EX	= 4,	//!< ガウシアンブラーEX

			TYPE_MAX		= 5,	//!< タイプ数
		};

		//! @brief コンストラクタ
		BLUR( void );

		//! @brief タイプを取得します
		//! @return タイプを表す Mix::Scene::BLUR::TYPE 列挙定数を返します
		BLUR::TYPE GetType( void ) const;
		//! @brief 整数型の値を取得します
		//! @return 値を返します
		Int32 GetIntValue( void ) const;
		//! @brief 浮動小数点型の値を取得します
		//! @return 値を返します
		Float32 GetFloatValue( void ) const;

		//! @brief 有効かどうかを確認します
		//! @return 有効( type != Mix::Scene::BLUR::T_NONE )な場合は True を返します
		Boolean IsValid( void ) const;

		//! @brief ブラーをかけない
		//! @return ブラーを表す Mix::Scene::BLUR 構造体を返します
		static const Mix::Scene::BLUR& NONE( void );

		//! @brief カーネルサイズが 3x3 のブラー
		//! @return ブラーを表す Mix::Scene::BLUR 構造体を返します
		//! @note 繰り返し数は 1 になります。
		static Mix::Scene::BLUR KS_3x3( void );
		//! @brief カーネルサイズが 3x3 のブラー
		//! @param[in] iteration 繰り返し数( 1〜16 )
		//! @return ブラーを表す Mix::Scene::BLUR 構造体を返します
		//! @note 繰り返し数は GetIntValue() で取得できます。
		static Mix::Scene::BLUR KS_3x3( Int32 iteration );

		//! @brief カーネルサイズが 5x5 のブラー
		//! @return ブラーを表す Mix::Scene::BLUR 構造体を返します
		//! @note 繰り返し数は 1 になります。
		static Mix::Scene::BLUR KS_5x5( void );
		//! @brief カーネルサイズが 5x5 のブラー
		//! @param[in] iteration 繰り返し数( 1〜16 )
		//! @return ブラーを表す Mix::Scene::BLUR 構造体を返します
		//! @note 繰り返し数は GetIntValue() で取得できます。
		static Mix::Scene::BLUR KS_5x5( Int32 iteration );

		//! @brief ガウシアンブラー
		//! @return ブラーを表す Mix::Scene::BLUR 構造体を返します
		//! @note 分散値は 0.0001f になります。
		static Mix::Scene::BLUR GAUSSIAN( void );
		//! @brief ガウシアンブラー
		//! @param[in] dispersion 分散値( 0.0001f〜128.0000f )
		//! @return ブラーを表す Mix::Scene::BLUR 構造体を返します
		//! @note
		//! 分散値は GetFloatValue() で取得できます。<br>
		//! また小数部は4桁までです。
		static Mix::Scene::BLUR GAUSSIAN( Float32 dispersion );

		//! @brief ガウシアンブラーEX
		//! @return ブラーを表す Mix::Scene::BLUR 構造体を返します
		//! @note
		//! 半径は 4 になります。<br>
		//! また シェーダーモデル3 ( DirectX9 ) では状況によって極端に重くなることがありますので、<br>
		//! 使用は控えてください。<br>
		static Mix::Scene::BLUR GAUSSIAN_EX( void );
		//! @brief ガウシアンブラーEX
		//! @param[in] radius 半径( 4〜64 )
		//! @return ブラーを表す Mix::Scene::BLUR 構造体を返します
		//! @note 半径は GetIntValue() で取得できます。
		static Mix::Scene::BLUR GAUSSIAN_EX( Int32 radius );

	private:
		BLUR::TYPE type;
		Int32 data;
	};

	//! @struct DYNAMICS_CONTACT_POINT
	//! @brief 接触ポイント構造体
	struct DYNAMICS_CONTACT_POINT
	{
		Mix::Vector3 localPositionA;		//!< 自身 : 接触ポイントのローカル座標
		Mix::Vector3 localPositionB;		//!< 相手 : 接触ポイントのローカル座標

		Mix::Vector3 worldPositionA;		//!< 共通 : 接触ポイントのワールド座標
		Mix::Vector3 worldPositionB;		//!< 共通 : 接触ポイントのワールド座標

		Mix::Vector3 worldNormalB;			//!< 相手 : 接触ポイントのワールド法線

		Float32 penetrationB;				//!< 接触ポイントの距離( めり込んでいる場合は、負の値になります )

		Mix::Dynamics::MATERIAL materialA;	//!< 自身 : 接触ポイントのマテリアル
		Mix::Dynamics::MATERIAL materialB;	//!< 相手 : 接触ポイントのマテリアル

		Float32 impulse;					//!< 接触ポイントに適用された撃力
	};

	//! @enum WATER_CONTAINS_RESULT
	//! @brief 水面との判定結果列挙定数
	enum WATER_CONTAINS_RESULT
	{
		WCR_UNKNOWN		= 0,	//!< 不明
		WCR_FRONT		= 1,	//!< 水面より手前
		WCR_BACK		= 2,	//!< 水面より奥
		WCR_OVERLAP		= 3,	//!< 水面と重なっている
	};

	//! @enum DYNAMICS_COLLIDER_MODE
	//! @brief ダイナミクスコライダーモード列挙定数
	enum DYNAMICS_COLLIDER_MODE
	{
		//! @brief デフォルト
		//! @note コライダーをモデルエディタで設定された状態にします。
		DC_DEFAULT		= 0,

		//! @brief スタティック
		//! @note
		//! 全てのコライダーを強制的にスタティック状態にします。
		DC_STATIC		= 1,

		//! @brief キネマティック
		//! @note 全てのコライダーを強制的にキネマティック状態にします
		DC_KINEMATIC	= 2,

		//! @brief ラグドール
		//! @note スタティック指定以外のコライダーをデフォルト状態にします
		DC_RAGDOLL		= 3,
	};

	//! @enum DYNAMICS_KCHAR_MODE
	//! @brief ダイナミクスキネマティックキャラクターモード
	enum DYNAMICS_KCHAR_MODE
	{
		//! @brief 受信
		//! @note モデルのワールドトランスフォームをキネマティックキャラクターに反映します
		DKC_RECEIVE	= 0,

		//! @brief 投影
		//! @note キネマティックキャラクターのワールドトランスフォームをモデルに反映します
		DKC_CAST	= 1,
	};

	//! @enum DEBUG_DRAW_METHOD
	//! @brief デバッグ : 描画メソッド列挙定数
	enum DEBUG_DRAW_METHOD
	{
		//! @brief パーティクル、モデルを描画する前にデバッグ描画を行います
		//! @note 半透明ポリゴンの後方にあるものも描画されますが、ポストエフェクトの影響を受けます
		DDM_BEFORE	= 0,

		//! @brief パーティクル、モデルを描画した後にデバッグ描画を行います
		//! @note ポストエフェクトの影響を受けませんが、半透明ポリゴンの後方にあるものは描画されなくなります
		DDM_AFTER	= 1,

		//! @brief 陰面処理を行わず、最前面にデバッグ描画を行います
		DDM_XRAYS	= 2,
	};

	//! @enum DEBUG_DRAW_FLAG
	//! @brief デバッグ : 描画フラグ列挙定数
	enum DEBUG_DRAW_FLAG
	{
		DDF_OCTREE				= 0x00000001,	//!< 八分木 : 境界

		DDF_DIRLIGHT_SHAPE		= 0x00000002,	//!< ディレクショナルライト : 形状

		DDF_SPOTLIGHT_SHAPE		= 0x00000004,	//!< スポットライト : 形状
		DDF_SPOTLIGHT_BOUNDS	= 0x00000008,	//!< スポットライト : 境界

		DDF_POINTLIGHT_SHAPE	= 0x00000010,	//!< ポイントライト : 形状
		DDF_POINTLIGHT_BOUNDS	= 0x00000020,	//!< ポイントライト : 境界

		DDF_SHADOW_BOUNDS		= 0x00000040,	//!< シャドウ : 境界

		DDF_WIDGET_GROUP_BOUNDS	= 0x00000080,	//!< ウィジェット : グループの境界

		DDF_PARTICLE_MESH		= 0x00000100,	//!< パーティクル : メッシュ
		DDF_PARTICLE_AXIS		= 0x00000200,	//!< パーティクル : 軸
		DDF_PARTICLE_BOUNDS		= 0x00000400,	//!< パーティクル : 境界
		DDF_PARTICLE_GENERATOR	= 0x00000800,	//!< パーティクル : ジェネレーター
		DDF_PARTICLE_PROCESSOR	= 0x00001000,	//!< パーティクル : プロセッサー

		DDF_PLANTER_MESH		= 0x00002000,	//!< プランター : メッシュ
		DDF_PLANTER_BOUNDS		= 0x00004000,	//!< プランター : 境界

		DDF_ACTORMODEL_MESH		= 0x00008000,	//!< アクターモデル : メッシュ
		DDF_ACTORMODEL_AXIS		= 0x00010000,	//!< アクターモデル : 軸
		DDF_ACTORMODEL_BOUNDS	= 0x00020000,	//!< アクターモデル : 境界
		DDF_ACTORMODEL_SKELETAL	= 0x00040000,	//!< アクターモデル : 骨格
		DDF_ACTORMODEL_KCHAR	= 0x00080000,	//!< アクターモデル : キネマティックキャラクタ
		DDF_ACTORMODEL_COLLIDER	= 0x00100000,	//!< アクターモデル : コライダー
		DDF_ACTORMODEL_SENSOR	= 0x00200000,	//!< アクターモデル : センサー
		DDF_ACTORMODEL_JOINT	= 0x00400000,	//!< アクターモデル : ジョイント

		DDF_TERRAINMODEL_MESH	= 0x00800000,	//!< テラインモデル : メッシュ
		DDF_TERRAINMODEL_BOUNDS	= 0x01000000,	//!< テラインモデル : 境界

		DDF_WATERPOOL_BOUNDS	= 0x02000000,	//!< ウォータープール : 境界

		DDF_PP_FILMIC			= 0x04000000,	//!< ポストプロセス : フィルミック
		DDF_PP_CHROMATISM		= 0x08000000,	//!< ポストプロセス : 色収差
		DDF_PP_LENS_DISTORTION	= 0x10000000,	//!< ポストプロセス : 歪曲収差

		DDF_FLOOR_COLLIDER		= 0x20000000,	//!< フロア : コライダー
		DDF_GHOST_COLLIDER		= 0x40000000,	//!< ゴースト : コライダー

		//! @brief メッシュ
		DDF_MESH				= ( DDF_PLANTER_MESH | DDF_PARTICLE_MESH | DDF_ACTORMODEL_MESH | DDF_TERRAINMODEL_MESH ),
		//! @brief 軸
		DDF_AXIS				= ( DDF_PARTICLE_AXIS | DDF_ACTORMODEL_AXIS ),
		//! @brief 境界
		DDF_BOUNDS				= ( DDF_SPOTLIGHT_BOUNDS | DDF_POINTLIGHT_BOUNDS | DDF_PARTICLE_BOUNDS | DDF_ACTORMODEL_BOUNDS | DDF_TERRAINMODEL_BOUNDS | DDF_WATERPOOL_BOUNDS | DDF_PLANTER_BOUNDS ),

		//! @brief 全てのライトの形状
		DDF_LIGHT_SHAPE			= ( DDF_DIRLIGHT_SHAPE | DDF_SPOTLIGHT_SHAPE | DDF_POINTLIGHT_SHAPE ),
		//! @brief 全てのライトの境界
		DDF_LIGHT_BOUNDS		= ( DDF_SPOTLIGHT_BOUNDS | DDF_POINTLIGHT_BOUNDS ),
		//! @brief 全てのライト
		DDF_LIGHT				= ( DDF_LIGHT_SHAPE | DDF_LIGHT_BOUNDS ),
		//! @brief ディレクショナルライト
		DDF_DIRLIGHT			= ( DDF_DIRLIGHT_SHAPE ),
		//! @brief スポットライト
		DDF_SPOTLIGHT			= ( DDF_SPOTLIGHT_SHAPE | DDF_SPOTLIGHT_BOUNDS ),
		//! @brief ポイントライト
		DDF_POINTLIGHT			= ( DDF_POINTLIGHT_SHAPE | DDF_POINTLIGHT_BOUNDS ),

		//! @brief シャドウ
		DDF_SHADOW				= ( DDF_SHADOW_BOUNDS ),

		//! @brief ウィジェット
		DDF_WIDGET				= ( DDF_WIDGET_GROUP_BOUNDS ),
		//! @brief プランター
		DDF_PLANTER				= ( DDF_PLANTER_MESH | DDF_PLANTER_BOUNDS ),
		//! @brief パーティクル
		DDF_PARTICLE			= ( DDF_PARTICLE_MESH | DDF_PARTICLE_AXIS | DDF_PARTICLE_BOUNDS | DDF_PARTICLE_GENERATOR | DDF_PARTICLE_PROCESSOR ),

		//! @brief アクターモデル
		DDF_ACTORMODEL			= ( DDF_ACTORMODEL_MESH | DDF_ACTORMODEL_AXIS | DDF_ACTORMODEL_BOUNDS | DDF_ACTORMODEL_SKELETAL | DDF_ACTORMODEL_KCHAR | DDF_ACTORMODEL_COLLIDER | DDF_ACTORMODEL_SENSOR | DDF_ACTORMODEL_JOINT ),
		//! @brief テラインモデル
		DDF_TERRAINMODEL		= ( DDF_TERRAINMODEL_MESH | DDF_TERRAINMODEL_BOUNDS ),

		//! @brief ウォータープール
		DDF_WATERPOOL			= ( DDF_WATERPOOL_BOUNDS ),

		//! @brief フロア
		DDF_FLOOR				= ( DDF_FLOOR_COLLIDER ),

		//! @brief ゴースト
		DDF_GHOST				= ( DDF_GHOST_COLLIDER ),

		//! @brief ダイナミクス
		DDF_DYNAMICS			= ( DDF_FLOOR |
									DDF_GHOST |
									DDF_ACTORMODEL_SKELETAL |
									DDF_ACTORMODEL_KCHAR |
									DDF_ACTORMODEL_COLLIDER |
									DDF_ACTORMODEL_SENSOR |
									DDF_ACTORMODEL_JOINT ),
	};

	//! @enum DEBUG_DRAW_COLOR_TYPE
	//! @brief デバッグ : 描画カラータイプ列挙定数
	enum DEBUG_DRAW_COLOR_TYPE
	{
		DDC_COLLIDER_AROUSAL		= 0,	//!< コライダー : 常に活動状態
		DDC_COLLIDER_ACTIVE			= 1,	//!< コライダー : 活動状態
		DDC_COLLIDER_SLEEPY			= 2,	//!< コライダー : 休止になる手前の状態
		DDC_COLLIDER_REST			= 3,	//!< コライダー : 休止状態
		DDC_COLLIDER_DISABLE		= 4,	//!< コライダー : 無効( シミュレーションは行われていない )

		DDC_SENSOR					= 5,	//!< センサー

		DDC_KINEMATIC_CHARACTER		= 6,	//!< キネマティックキャラクター

		DDC_JOINT_FRAME				= 7,	//!< ジョイント : フレーム
		DDC_JOINT_LIMIT				= 8,	//!< ジョイント : リミット

		DDC_BOUNDS					= 9,	//!< 境界

		DDC_OCTREE_NODE_BOUNDS		= 10,	//!< オクトリー : ノードの境界
		DDC_OCTREE_OBJS_BOUNDS		= 11,	//!< オクトリー : オブジェクトの境界

		DDC_LIGHT_SHAPE				= 12,	//!< ライト : 形状
		DDC_PARTICLE_QUAD			= 13,	//!< パーティル : 矩形
		DDC_ACTORMODEL_SKELETAL		= 14,	//!< アクターモデル : 骨格
		DDC_SM_CLIP_BOOUNDS			= 15,	//!< シャドウマッピング : クリップ境界
		DDC_SM_CAST_BOOUNDS			= 16,	//!< シャドウマッピング : キャスト境界

		DDC_FILMIC_BG				= 17,	//!< フィルミック : 背景
		DDC_FILMIC_MEMORY			= 18,	//!< フィルミック : メモリ
		DDC_FILMIC_CURVE			= 19,	//!< フィルミック : カーブ

		DDC_ABERRATION				= 20,	//!< 色収差、歪曲収差の格子の色
	};

	//! @enum DEBUG_PROFILE_TYPE
	//! @brief デバッグ : プロファイルタイプ列挙定数
	enum DEBUG_PROFILE_TYPE
	{
		DPT_GENERAL				= 0,	//!< 全体
		DPT_DYNAMICS			= 1,	//!< ダイナミクス
		DPT_OCTREE				= 2,	//!< 八分木
		DPT_LIGHT				= 3,	//!< ライト
		DPT_WATER_POOL			= 4,	//!< ウォータープール
		DPT_WIDGET				= 5,	//!< ウィジェット
		DPT_ACTOR_MODEL			= 6,	//!< アクターモデル
		DPT_TERRAIN_MODEL		= 7,	//!< テラインモデル
		DPT_PROJ_SHADOW			= 8,	//!< シャドウの投影
		DPT_DRAW_OPACITY		= 9,	//!< 不透明の描画
		DPT_DRAW_NEUTRALITY		= 10,	//!< 不透明の描画と屈折の描画の間に行われる描画
		DPT_DRAW_REFRACT		= 11,	//!< 屈折の描画
		DPT_DRAW_TRANSPARENCY	= 12,	//!< 半透明の描画
		DPT_POST_PROCESS		= 13,	//!< ポストプロセス
	};

	//! @struct DEBUG_PROFILE_RENDERER_GENERAL
	//! @brief デバッグ : レンダラー : ジェネラルプロファイル構造体
	struct DEBUG_PROFILE_RENDERER_GENERAL
	{
		Float32 updElapsedTime;		//!< 更新( Mix::Scene::IRenderer::Update )にかかった時間( 秒単位 )
		Float32 refElapsedTime;		//!< リフレッシュ( Mix::Scene::IRenderer::Refresh )にかかった時間( 秒単位 )
		Float32 drawElapsedTime;	//!< 全てのカメラによる描画( Mix::Scene::ICamera::Draw )にかかった時間( 秒単位 )
		Float32 finElapsedTime;		//!< 後処理にかかった時間( 秒単位 )

		UInt32 drawPrimCount;		//!< 全てのカメラにより描画されたプリミティブ数
	};

	//! @struct DEBUG_PROFILE_RENDERER_DYNAMICS
	//! @brief デバッグ : レンダラー : ダイナミクスプロファイル構造体
	//! @note この構造体のパラメータの値は、Mix::Scene::IRenderer::Update によって更新されます。
	struct DEBUG_PROFILE_RENDERER_DYNAMICS
	{
		Float32 ssElapsedTime;	//!< シミュレーションにかかった時間( 秒単位 )
		Float32 cpElapsedTime;	//!< 接触情報の収集にかかった時間( 秒単位 )
	};

	//! @struct DEBUG_PROFILE_RENDERER_OCTREE
	//! @brief デバッグ : レンダラー : 八分木プロファイル構造体
	//! @note この構造体のパラメータの値は、Mix::Scene::IRenderer::Refresh によって更新されます。
	struct DEBUG_PROFILE_RENDERER_OCTREE
	{
		UInt32 nodeCount;						//!< 現在のノード数
		UInt32 nodeMax;							//!< ノードの最大数
		Mix::Vector3 unitSize;					//!< リーフとなる子空間のサイズ

		UInt32 illegalLocalLightNum;			//!< イリーガルなローカルライトの数
		UInt32 illegalLeavingParticleNum;		//!< イリーガルなリービングパーティクルの数
		UInt32 illegalScatterParticleUnitNum;	//!< イリーガルなスキャッターパーティクルのユニットの数
		UInt32 illegalActorModelNum;			//!< イリーガルなアクターモデルの数
	};

	//! @struct DEBUG_PROFILE_CAMERA_GENERAL
	//! @brief デバッグ : カメラ : ジェネラルプロファイル構造体
	struct DEBUG_PROFILE_CAMERA_GENERAL
	{
		Float32 drawElapsedTime;	//!< 描画( Mix::Scene::ICamera::Draw )にかかった時間( 秒単位 )
		UInt32 drawPrimCount;		//!< 描画されたプリミティブ数
	};

	//! @struct DEBUG_PROFILE_CAMERA_OCTREE
	//! @brief デバッグ : カメラ : 八分木プロファイル構造体
	struct DEBUG_PROFILE_CAMERA_OCTREE
	{
		Float32 ccElapsedTime;	//!< 描画するオブジェクトの収集にかかった時間( 秒単位 )
		Float32 csElapsedTime;	//!< 影として投影するオブジェクトの収集にかかった時間( 秒単位 )
		Float32 fElapsedTime;	//!< オブジェクト収集後の処理にかかった時間( 秒単位 )
	};

	//! @struct DEBUG_PROFILE_CAMERA_LIGHT
	//! @brief デバッグ : カメラ : ライトプロファイル構造体
	struct DEBUG_PROFILE_CAMERA_LIGHT
	{
		UInt32 vSpotCount;		//!< 視界に入っているスポットライトの数
		UInt32 tSpotCount;		//!< 全てのスポットライトの数

		UInt32 vPointCount;		//!< 視界に入って利うポイントライトの数
		UInt32 tPointCount;		//!< 全てのポイントライトの数

		Float32 vcElapsedTime;	//!< 視界に入っているローカルライトの収集にかかった時間( 秒単位 )
		Float32 vsElapsedTime;	//!< 視界に入っているローカルライトのソートにかかった時間( 秒単位 )
	};

	//! @struct DEBUG_PROFILE_CAMERA_WATER_POOL
	//! @brief デバッグ : カメラ : ウォータープールプロファイル
	struct DEBUG_PROFILE_CAMERA_WATER_POOL
	{
		Float32 vElapsedTime;	//!< 視界に入っているウォータープールの数
		UInt32 vCount;			//!< 視界に入っている全てウォータープールの数
		UInt32 vrCount;			//!< 視界に入っている屈折判定に使用されているウォータープールの数
		UInt32 tCount;			//!< 全てのウォータープールの数
	};

	//! @struct DEBUG_PROFILE_CAMERA_WIDGET
	//! @brief デバッグ : カメラ : ウィジェットプロファイル構造体
	struct DEBUG_PROFILE_CAMERA_WIDGET
	{
		//! @struct DEBUG_PROFILE_LEAVING_PARTICLE
		//! @brief デバッグ : リービングパーティクルプロファイル構造体
		struct DEBUG_PROFILE_LEAVING_PARTICLE
		{
			UInt32 vCount;			//!< 視界に入っているリービングパーティクルの数
			UInt32 tCount;			//!< 全てのリービングパーティクルの数
			Float32 vElapsedTime;	//!< 視界に入っているリービングの収集にかかった時間( 秒単位 )
		}lp; //!< リービングパーティクルプロファイル

		//! @struct DEBUG_PROFILE_SCATTER_PARTICLE
		//! @brief デバッグ : スキャッターパーティクルプロファイル構造体
		struct DEBUG_PROFILE_SCATTER_PARTICLE
		{
			UInt32 vCount;		//!< 視界に入っているスキャッターパーティクルのユニットの数
			UInt32 tCount;		//!< 全てのスキャッターパーティクルのユニットの数
			Float32 vElapsedTime;	//!< 視界に入っているスキャッターパーティクルの収集にかかった時間( 秒単位 )
		}sp; //!< スキャッターパーティクルプロファイル

		//! @struct DEBUG_PROFILE_PLANTER
		//! @brief デバッグ : プランタープロファイル構造体
		struct DEBUG_PROFILE_PLANTER
		{
			UInt32 vCount;			//!< 視界に入っているプランターの数
			UInt32 tCount;			//!< 全てのプランターの数
			Float32 vElapsedTime;	//!< 視界に入っているプランターの収集にかかった時間( 秒単位 )
		}pl; //!< プランタープロファイル

		UInt32 subsetCount;		//!< サブセットの数
		UInt32 quadCount;		//!< クワッドの数
		UInt32 objCount;		//!< サブセット、もしくわクワッドから生成された半透明オブジェクトの数
		UInt32 comCount;		//!< 半透明オブジェクトを元に生成されたコマンドの数

		Float32 slElapsedTime;	//!< ローカルライティングを行うウィジェットのソートにかかった時間( 秒単位 )
		Float32 alElapsedTime;	//!< ローカルライティングにかかった時間( 秒単位 )
		Float32 goElapsedTime;	//!< サブセットから半透明オブジェクトの生成にかかった時間( 秒単位 )
	};

	//! @struct DEBUG_PROFILE_CAMERA_MODEL
	//! @brief デバッグ : カメラ : モデルプロファイル構造体
	struct DEBUG_PROFILE_CAMERA_MODEL
	{
		UInt32 vCount;			//!< 視界に入っているモデルの数
		UInt32 sCount;			//!< シャドウマッピングを行ったモデルの数
		UInt32 tCount;			//!< 全てのモデルの数
		Float32 vcElapsedTime;	//!< 視界に入っているモデルの収集、コマンドの生成にかかった時間( 秒単位 )
		Float32 cmElapsedTime;	//!< シャドウマッピングを行うモデルの収集にかかった時間( 秒単位 )
	};

	//! @struct DEBUG_PROFILE_CAMERA_PROJ_SHADOW
	//! @brief デバッグ : カメラ : シャドウ投影プロファイル構造体
	struct DEBUG_PROFILE_CAMERA_PROJ_SHADOW
	{
		UInt32 comCount;			//!< コマンドの数
		UInt32 comCapacity;			//!< コマンドのキャパシティ

		Float32 preElapsedTime;		//!< 事前処理( ソート )にかかった時間( 秒単位 )
		Float32 drawElapsedTime;	//!< 描画にかかった時間( 秒単位 )
	};

	//! @struct DEBUG_PROFILE_CAMERA_DRAW_OPACITY
	//! @brief デバッグ : カメラ : 不透明描画プロファイル構造体
	struct DEBUG_PROFILE_CAMERA_DRAW_OPACITY
	{
		UInt32 comCount;			//!< コマンドの数
		UInt32 comCapacity;			//!< コマンドのキャパシティ

		Float32 preElapsedTime;		//!< 事前処理( ソート )にかかった時間( 秒単位 )
		Float32 drawElapsedTime;	//!< 描画にかかった時間( 秒単位 )
	};

	//! @struct DEBUG_PROFILE_CAMERA_DRAW_NEUTRALITY
	//! @brief デバッグ : カメラ : 不透明描画と半透明描画( 屈折描画含む )の間の描画プロファイル構造体
	struct DEBUG_PROFILE_CAMERA_DRAW_NEUTRALITY
	{
		Float32 aoElapsedTime;	//!< アンビエントオクルージョンにかかった時間( 秒単位 )
		Float32 asElapsedTime;	//!< 大気の描画にかかった時間( 秒単位 )
	};

	//! @struct DEBUG_PROFILE_CAMERA_DRAW_REFRACT
	//! @brief デバッグ : カメラ : 屈折描画プロファイル構造体
	struct DEBUG_PROFILE_CAMERA_DRAW_REFRACT
	{
		UInt32 comCount;			//!< コマンドの数
		UInt32 comCapacity;			//!< コマンドのキャパシティ

		Float32 maskElapsedTime;	//!< 屈折マスクの描画にかかった時間( 秒単位 )
		Float32 drawElapsedTime;	//!< 屈折の描画にかかった時間( 秒単位 )
	};

	//! @struct DEBUG_PROFILE_CAMERA_DRAW_TRANSPARENCY
	//! @brief デバッグ : カメラ : 半透明プロファイル構造体
	struct DEBUG_PROFILE_CAMERA_DRAW_TRANSPARENCY
	{
		UInt32 objCount;			//!< オブジェクト数
		UInt32 objCapacity;			//!< オブジェクトのキャパシティ

		UInt32 comCount;			//!< コマンドの数
		UInt32 comCapacity;			//!< コマンドのキャパシティ

		UInt32 bkComCount;			//!< 屈折面より後ろの描画に使用されたコマンドの数( 屈折面と重なっているものも含む )
		UInt32 bkComCapacity;		//!< 屈折面より後ろの描画に使用されたコマンドのキャパシティ

		UInt32 frComCount;			//!< 屈折面より前の描画に使用されたコマンドの数( 屈折面と重なっているものも含む )
		UInt32 frComCapacity;		//!< 屈折面より前の描画に使用されたコマンドのキャパシティ

		UInt32 ovComCount;			//!< 屈折面と重なっている(オーバラップ)コマンドの数

		Float32 soElapsedTime;		//!< オブジェクトのソートにかかった時間( 秒単位 )
		Float32 gcElapsedTime;		//!< オブジェクトからコマンドの生成にかかった時間( 秒単位 )
		Float32 dcElapsedTime;		//!< 屈折面に対する前後のコマンドの分割にかかった時間( 秒単位 )
		Float32 bkElapsedTime;		//!< 屈折面より後ろの描画にかかった時間( 秒単位 )
		Float32 frElapsedTime;		//!< 屈折面より前の描画にかかった時間( 秒単位 )
	};

	//! @struct DEBUG_PROFILE_CAMERA_POST_PROCESS
	//! @brief デバッグ : カメラ : ポストプロセスプロファイル構造体
	struct DEBUG_PROFILE_CAMERA_POST_PROCESS
	{
		Float32 smElapsedTime;		//!< シャドウマッピングにかかった時間( 秒単位 )
		Float32 uwElapsedTime;		//!< 水面下処理にかかった時間( 秒単位 )
		Float32 lumTrElapsedTime;	//!< 輝度の変換、順応にかかった時間( 秒単位 )
		Float32 lbElapsedTime;		//!< ブルームにかかった時間( 秒単位 )
		Float32 lsElapsedTime;		//!< ライトシャフトにかかった時間( 秒単位 )
		Float32 lfElapsedTime;		//!< レンズフレアにかかった時間( 秒単位 )
		Float32 lumOpElapsedTime;	//!< 輝度の適用処理にかかった時間( 秒単位 )
		Float32 fmElapsedTime;		//!< フィルミックにかかった時間( 秒単位 )
		Float32 gcElapsedTime;		//!< ガンマ補正にかかった時間( 秒単位 )
		Float32 mbElapsedTime;		//!< モーションブラーにかかった時間( 秒単位 )
		Float32 caElapsedTime;		//!< 色収差処理にかかった時間( 秒単位 )
		Float32 dofElapsedTime;		//!< 被写界深度処理にかかった時間( 秒単位 )
		Float32 ldElapsedTime;		//!< 歪曲収差にかかった時間( 秒単位 )
		Float32 viElapsedTime;		//!< ヴィネットにかかった時間( 秒単位 )
		Float32 aaElapsedTime;		//!< アンチエイリアシングにかかった時間( 秒単位 )
		Float32 finalElapsedTime;	//!< 最終処理( バックバッファへのコピー )にかかった時間( 秒単位 )
	};

	//! @enum DEBUG_IMAGE_TYPE
	//! @brief デバッグ : イメージ列挙定数
	enum DEBUG_IMAGE_TYPE
	{
		//! @brief 深度
		DIT_DEPTH				= 0,

		//! @brief データ
		//! @note
		//! RGB=ビュー法線<br>
		//! A=スカイドームを除いたマスク
		DIT_DATA				= 1,

		//! @brief アンビエントオクルージョン
		//! @note
		//! 0:カラー<br>
		//! 1:カラーのぼかし
		DIT_AMBIENT_OCCLUSION	= 2,

		//! @brief シャドウマッピング
		//! @note
		//! 0:深度<br>
		//! 1:カラー<br>
		//! 2:カラーのぼかし<br>
		DIT_SHADOW_MAPPING		= 3,

		//! @brief ルミノシティ
		//! @note
		//! 0:現在の輝度<br>
		//! 1:順応した輝度
		DIT_LUMINOSITY			= 4,

		//! @brief ブルーム
		//! @note
		//! 0:ブライトパス<br>
		//! 1以降:オーバーフロー
		DIT_BLOOM				= 5,

		//! @brief ライトシャフト
		//! @note
		//! 0:ブライトパス<br>
		//! 1:カラー
		DIT_LIGHT_SHAFTS		= 6,

		//! @brief レンズフレア
		//! @note
		//! 0:ブライトパス<br>
		//! 1:カラー
		DIT_LENS_FLARE			= 7,

		//! @brief 色収差
		//! @note
		//! 0:カラーの差分
		DIT_CHROMATISM			= 8,

		//! @brief 被写界深度
		//! @note
		//! 0:カラーのぼかし1<br>
		//! 1:カラーのぼかし2
		DIT_DOF					= 9,
	};

	//! @brief マネージャのポインタを取得します
	//! @return マネージャを表す Mix::Scene::IManager インターフェースのポインタを返します
	_MIX_DLL_API Mix::Scene::IManager* GetManagerPtr( void );
	//! @brief マネージャを取得します
	//! @param[out] ppManager マネージャを表す Mix::Scene::IManager インターフェースのポインタのアドレス
	//! @return 成功した場合は True を返します
	//! @note 取得したマネージャは参照カウンタを +1 します。
	_MIX_DLL_API Boolean GetManager( Mix::Scene::IManager** ppManager );

}}

//! @namespace Mix
//! @brief ミックス
namespace Mix{

	class IEngine;

	//! @struct ENGINE_CONFIG_FLAG
	//! @brief エンジン設定フラグ列挙定数
	enum ENGINE_CONFIG_FLAG
	{
		//! @brief 入出力 ( Mix::IO ) をマウントされた、ファイル、ディレクトリに限定する
		//! @note
		//! このフラグを指定しなかった場合は、以下のメソッドは機能しません。<br>
		//! <br>
		//! Mix::IO::IManager::MountArchive<br>
		//! Mix::IO::IManager::MountDirectory<br>
		//! Mix::IO::IManager::MountFile<br>
		EC_IO_NARROW	= 0x00000001,
		//! @brief キーボード ( Mix::HID::IKeyboard ) を使用する
		EC_KEYBOARD		= 0x00000002,
		//! @brief マウス ( Mix::HID::IMouse ) を使用する
		EC_MOUSE		= 0x00000004,
		//! @brief ゲームパッド ( Mix::HID::IGamepad ) を使用する
		EC_GAMEPAD		= 0x00000008,
		//! @brief ヒューマンインターフェースデバイス ( Mix::HID ) を使用する
		EC_HID			= EC_KEYBOARD | EC_MOUSE | EC_GAMEPAD,
		//! @brief グラフィックス ( Mix::Graphics ) を使用する
		EC_GRAPHICS		= 0x00000010,
		//! @brief サウンド ( Mix::Sound ) を使用する
		EC_SOUND		= 0x00000020,
		//! @brief ダイナミクス ( Mix::Dynamics ) を使用する
		EC_DYNAMICS		= 0x00000040,
		//! @brief 並列処理 ( Mix::Parallel ) を使用する
		EC_PARALLEL		= 0x00000080,
		//! @brief シーン ( Mix::Scene ) を使用する
		EC_SCENE		= 0x00000100,

		//! @brief 全てを使用する
		EC_ALL		= EC_IO_NARROW | EC_HID | EC_GRAPHICS | EC_SOUND | EC_DYNAMICS | EC_PARALLEL | EC_SCENE,
	};

	//! @struct ENGINE_CONFIG
	//! @brief エンジン設定構造体
	struct ENGINE_CONFIG
	{
		//! @brief 使用する機能を Mix::ENGINE_CONFIG_FLAG 列挙定数の組み合わせで指定します。
		UInt32 flags;

		//! @brief 外部ウィンドウのハンドル
		//! @note 内部でウィンドウを作成する場合は NULL にしておく必要がります。<br>
		HWND hWnd;

		//! @brief ターゲットのサイズ
		//! @note
		//! 内部ウィンドウを使用する場合は、ウィンドウのクライアント、グラフィックスのバックバッファのサイズになります。<br>
		//! また、サイズ変更可能な外部ウィンドウが指定されている場合は、この値は無視され、<br>
		//! グラフィックスのバックバッファのサイズは、現在のディスプレイの解像度が使用されます。<br>
		Mix::Point targetSize;

		//! @brief ウィンドウのタイトルバーに表示される文字列
		//! @note 外部ウィンドウが指定されている場合は無視されます。
		const wchar_t* pCaption;
		//! @brief ウィンドウのタイトルバーに表示されるアイコンのハンドル
		//! @note 外部ウィンドウが指定されている場合は無視されます。
		HICON hIcon;
		//! @brief ウィンドウのタイトルバーに表示される小さいアイコンのハンドル
		//! @note 外部ウィンドウが指定されている場合は無視されます。
		HICON hSmallIcon;
		//! @brief ドラッグドロップを受け入れるかどうか
		//! @note 外部ウィンドウが指定されている場合は無視されます。
		Boolean bAcceptDrop;

		//! @brief 毎秒のフレーム数<br>
		//! ( frameRate > 0 )  : 毎秒のフレーム数を制限し、FPSを計測します<br>
		//! ( frameRate == 0 ) : 毎秒のフレーム数を制限せず、FPSを計測します<br>
		//! ( frameRate < 0 )  : 毎秒のフレーム数を制限せず、FPSも計測しません
		Int32 baseFPS;
		//! @brief 毎フレームに空き時間が無い場合に他のスレッドにタイムスライスを譲る( Sleep( 0 ) )フレーム数
		Int32 insomniaFrames;

		//! @brief ルートディレクトリのパス
		//! @note
		//! NULL を指定するとプロセスのディレクトリになります。<br>
		//! また、相対パスを指定するとカレントディレクトリをベースとした絶対パスになります。
		const wchar_t* pRootDirectoryPath;
		//! @brief プラグインが入っているディレクトリのパス
		//! @note
		//! NULL を指定するとカレントディレクトリを指定したことになります。<br>
		//! また、相対パスを指定した場合、ルートディレクトリをベースとした絶対パスになります。
		const wchar_t* pPluginDirectoryPath;
		//! @brief ユーザーディレクトリのパス
		//! @note マイドキュメントからの相対パスを指定します。
		const wchar_t* pUserDirectoryPath;

		//! @brief 使用するシェーダーモデル
		Mix::Graphics::SHADER_MODEL shaderModel;
		//! @brief フルスクリーンで起動する場合は True
		Boolean bFullscreen;
		//! @brief 垂直同期を待って描画する場合は True
		Boolean bWaitVSync;

		//! @brief テキストのタブサイズ
		//! @note 最小値は 2 です。
		Int32 textTabSize;
		//! @brief テキスト( フォント )を書き込むターゲットテクスチャの一辺の長さ
		Int32 textTargetSize;
		//! @brief テキスト( フォント )を書き込むターゲットテクスチャの初期ページ数
		Int32 initialTextTargetNum;

		//! @brief コンストラクタ
		ENGINE_CONFIG( void )
		{
			flags = Mix::EC_ALL;

			hWnd = NULL;

			pCaption = NULL;
			hIcon = NULL;
			hSmallIcon = NULL;
			bAcceptDrop = False;

			pRootDirectoryPath = NULL;
			pPluginDirectoryPath = NULL;
			pUserDirectoryPath = NULL;

			baseFPS = 60;
			insomniaFrames = 15;

			targetSize.x = 1024;
			targetSize.y = 768;

			shaderModel = Mix::Graphics::SHADER_MODEL_3;
			bFullscreen = False;
			bWaitVSync = False;

			textTabSize = 4;
			textTargetSize = 512;
			initialTextTargetNum = 2;
		}
	};

	//! @fn void MessageProc( HWND hWnd, UInt32 msg, WPARAM wp, LPARAM lp, void* pData )
	//! @brief メッセージプロシージャー
	//! @param hWnd ウィインドウハンドル
	//! @param message メッセージ
	//! @param wParam メッセージの追加データ 1
	//! @param lParam メッセージの追加データ 2 
	//! @param pData データ
	typedef void __stdcall MessageProc( HWND hWnd, UInt32 message, WPARAM wParam, LPARAM lParam, void* pData );

	//! @typedef MessageProcPtr
	//! @brief Mix::MessageProc のポインタ
	typedef MessageProc* MessageProcPtr;

	//! @brief Mixを初期化します
	//! @return 成功した場合は True を返します
	_MIX_DLL_API Boolean Initialize( const Mix::ENGINE_CONFIG& config );
	//! @brief Mixを終了します
	_MIX_DLL_API void Finalize( void );

	//! @brief インスタンスのハンドルを取得します
	//! @return ハンドルを返します
	_MIX_DLL_API HINSTANCE GetInstanceHandle( void );

	//! @brief エンジンのポインタを取得します
	//! @return エンジンのポインタを表す Mix::IEngine インターフェースのポインタを返します
	_MIX_DLL_API Mix::IEngine* GetEnginePtr( void );
	//! @brief エンジンを取得します
	//! @param[out] ppEngine エンジンを表す Mix::IEngine インターフェースのポインタのアドレス
	//! @note 取得したエンジンは参照カウンタを +1 します。
	_MIX_DLL_API Boolean GetEngine( Mix::IEngine** ppEngine );

	//! @brief 整数の符号を取得します
	//! @param[in] value 符号を判定する値
	//! @return 整数の符号を返します
	_MIX_DLL_API Int32 Sign( Int32 value );
	//! @brief 浮動小数点の符号を取得します
	//! @param[in] value 符号を判定する値
	//! @return 浮動小数点の符号を返します
	_MIX_DLL_API Float32 SignF( Float32 value );

	//! @brief 浮動小数点の平方根を取得します
	//! @param[in] value 平方根を求める値
	//! @return 浮動小数点の平方根を返します
	_MIX_DLL_API Float32 SqrtF( const Float32& value );

	//! @brief 浮動小数点の逆数を取得します
	//! @param[in] value 逆数を求める値
	//! @return 逆数を返します
	_MIX_DLL_API Float32 InvF( Float32 value );
	//! @brief 浮動小数点の平方根の逆数を取得します
	//! @param[in] value 平方根の逆数を求める値
	//! @return 平方根の逆数を返します
	_MIX_DLL_API Float32 InvSqrtF( Float32 value );

	//! @brief 乱数を初期化します
	_MIX_DLL_API void InitRand( void );
	//! @brief 乱数を初期化します
	//! @param[in] seed 乱数のもとになる数字
	_MIX_DLL_API void InitRand( UInt32 seed );
	//! @brief 乱数を初期化します
	//! @param[in] seeds 乱数のもとになる数字の配列
	//! @param[in] numSeed 乱数のもとになる数字の配列の要素の数
	_MIX_DLL_API void InitRand( UInt32* seeds, UInt32 numSeed );
	//! @brief 整数の乱数を取得します
	//! @return 整数の乱数を返します
	_MIX_DLL_API UInt32 Rand( void );
	//! @brief 整数の乱数を取得します
	//! @param[in] maxRnd 取得する乱数の最大値
	//! @return 整数の乱数を返します
	_MIX_DLL_API UInt32 Rand( UInt32 maxRnd );
	//! @brief 整数の乱数を取得します
	//! @param[in] r0 取得する乱数の開始値
	//! @param[in] r1 取得する乱数の終了値
	//! @return 整数の乱数を返します
	_MIX_DLL_API UInt32 Rand( UInt32 r0, UInt32 r1 );
	//! @brief 浮動小数点の乱数( 0.0f〜1.0f )を取得します
	//! @return 浮動小数点の乱数を返します
	_MIX_DLL_API Float32 RandF( void );
	//! @brief 浮動小数点の乱数を取得します
	//! @param[in] maxRnd 取得する乱数の最大値
	//! @return 浮動小数点の乱数を返します
	_MIX_DLL_API Float32 RandF( Float32 maxRnd );
	//! @brief 浮動小数点の乱数を取得します
	//! @param[in] r0 取得する乱数の開始値
	//! @param[in] r1 取得する乱数の終了値
	//! @return 浮動小数点の乱数を返します
	_MIX_DLL_API Float32 RandF( Float32 r0, Float32 r1 );

	//! @brief 浮動小数点の線形補間をします
	//! @param[in] a 補間元
	//! @param[in] b 補間先
	//! @param[in] t 補間係数( 0.0f〜1.0f )
	//! @return 補間された浮動小数点を返します
	_MIX_DLL_API Float32 LerpF( Float32 a, Float32 b, Float32 t );

	//! @brief 指定されたベクトルから２本の垂直なベクトルを求めます
	//! @param[in] n 入力ベクトルを表す Mix::Vector3 クラス
	//! @param[out] p 出力ベクトル１を表す Mix::Vector3 クラス
	//! @param[out] q 出力ベクトル２を表す Mix::Vector3 クラス
	_MIX_DLL_API void PlaneSpace( const Mix::Vector3& n, Mix::Vector3& p, Mix::Vector3& q );

	//! @brief 指定された直行する２本のベクトルから最短の回転を求めます
	//! @param[in] v0 一つ目のベクトルを表す Mix::Vector3 クラス
	//! @param[in] v1 二つ目のベクトルを表す Mix::Vector3 クラス
	//! @return 回転を表す Mix::Quaternion クラスを返します
	_MIX_DLL_API Mix::Quaternion ShortestArc( const Mix::Vector3& v0, const Mix::Vector3& v1 );

	//! @brief ワールド座標をスクリーン座標へ変換します
	//! @param[in] viewMat ビュー行列を表す Mix::Matrix4x4 クラス
	//! @param[in] projMat 射影行列を表す Mix::Matrix4x4 クラス
	//! @param[in] worldPos ワールド座標を表す Mix::Vector3 クラス
	//! @param[in] screenSize スクリーンのサイズを表す Mix::Vector2 クラス
	//! @return スクリーン座標を表す Mix::Vector3 クラスを返します
	_MIX_DLL_API Mix::Vector3 Project( const Mix::Matrix4x4& viewMat, const Mix::Matrix4x4& projMat, const Mix::Vector3& worldPos, const Mix::Vector2& screenSize );
	//! @brief スクリーン座標をワールド座標へ変換します
	//! @param[in] viewMat ビュー行列を表す Mix::Matrix4x4 クラス
	//! @param[in] projMat 射影行列を表す Mix::Matrix4x4 クラス
	//! @param[in] screenPos スクリーン座標( z は射影空間の値 0.0f 〜 1.0f )を表す Mix::Vector3 クラス
	//! @param[in] screenSize スクリーンのサイズを表す Mix::Vector2 クラス
	//! @return ワールド座標を表す Mix::Vector3 クラスを返します
	_MIX_DLL_API Mix::Vector3 Unproject( const Mix::Matrix4x4& viewMat, const Mix::Matrix4x4& projMat, const Mix::Vector3& screenPos, const Mix::Vector2& screenSize );
}
