using System ;
using System.Collections.Generic ;
using System.Runtime.InteropServices ;
using System.Text ;


namespace DxLibDLL
{


	public static partial class DX
	{


		/// <summary> モデルの読み込み( -1:エラー  0以上:モデルハンドル ) </summary>
		public static Model MV1LoadModel( string FileName )
		{
			lock( locker )
			{
				int result = dx_MV1LoadModel( FileName ) ;
				if( !( result != -1 ) ) { throw new DX.Exception(); }
				return Model.FromHandle( result ) ;
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1LoadModel( string FileName ) ;


		/// <summary> 指定のモデルと同じモデル基本データを使用してモデルを作成する( -1:エラー  0以上:モデルハンドル ) </summary>
		public static Model MV1DuplicateModel( Model SrcMHandle )
		{
			lock( locker )
			{
				int result = dx_MV1DuplicateModel( Model.ToHandle( SrcMHandle ) ) ;
				if( !( result != -1 ) ) { throw new DX.Exception(); }
				return Model.FromHandle( result ) ;
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1DuplicateModel( int SrcMHandle ) ;


		/// <summary> モデルを読み込む際に法線の再計算を行うかどうかを設定する( TRUE:行う  FALSE:行わない ) </summary>
		public static void MV1SetLoadModelReMakeNormal( bool Flag )
		{
			lock( locker )
			{
				int result = dx_MV1SetLoadModelReMakeNormal( Flag ) ;
				if( !( result == 0 ) ) { throw new DX.Exception(); }
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1SetLoadModelReMakeNormal( bool Flag ) ;


		/// <summary> モデルを読み込む際に行う法泉の再計算で使用するスムージング角度を設定する( 単位はラジアン ) </summary>
		public static void MV1SetLoadModelReMakeNormalSmoothingAngle()
		{
			MV1SetLoadModelReMakeNormalSmoothingAngle( ( float )( Math.PI / 2 ) ) ;
		}

		/// <summary> モデルを読み込む際に行う法泉の再計算で使用するスムージング角度を設定する( 単位はラジアン ) </summary>
		public static void MV1SetLoadModelReMakeNormalSmoothingAngle( float SmoothingAngle )
		{
			lock( locker )
			{
				int result = dx_MV1SetLoadModelReMakeNormalSmoothingAngle( SmoothingAngle ) ;
				if( !( result == 0 ) ) { throw new DX.Exception(); }
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1SetLoadModelReMakeNormalSmoothingAngle( float SmoothingAngle ) ;


		/// <summary> モデルを読み込む際に座標データの最適化を行うかどうかを設定する( TRUE:行う  FALSE:行わない ) </summary>
		public static void MV1SetLoadModelPositionOptimize( bool Flag )
		{
			lock( locker )
			{
				int result = dx_MV1SetLoadModelPositionOptimize( Flag ) ;
				if( !( result == 0 ) ) { throw new DX.Exception(); }
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1SetLoadModelPositionOptimize( bool Flag ) ;


		/// <summary> モデルを描画する </summary>
		public static void MV1DrawModel( Model MHandle )
		{
			lock( locker )
			{
				int result = dx_MV1DrawModel( Model.ToHandle( MHandle ) ) ;
				if( !( result == 0 ) ) { throw new DX.Exception(); }
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1DrawModel( int MHandle ) ;


		/// <summary> モデルの指定のフレームを描画する </summary>
		public static void MV1DrawFrame( Model MHandle , int FrameIndex )
		{
			lock( locker )
			{
				int result = dx_MV1DrawFrame( Model.ToHandle( MHandle ) , FrameIndex ) ;
				if( !( result == 0 ) ) { throw new DX.Exception(); }
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1DrawFrame( int MHandle , int FrameIndex ) ;


		/// <summary> モデルの指定のメッシュを描画する </summary>
		public static void MV1DrawMesh( Model MHandle , int MeshIndex )
		{
			lock( locker )
			{
				int result = dx_MV1DrawMesh( Model.ToHandle( MHandle ) , MeshIndex ) ;
				if( !( result == 0 ) ) { throw new DX.Exception(); }
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1DrawMesh( int MHandle , int MeshIndex ) ;


		/// <summary> モデルのデバッグ描画 </summary>
		public static void MV1DrawModelDebug( Model MHandle , COLOR_U8 Color , bool IsNormalLine , float NormalLineLength , bool IsPolyLine , bool IsCollisionBox )
		{
			lock( locker )
			{
				int result = dx_MV1DrawModelDebug( Model.ToHandle( MHandle ) , Color , IsNormalLine , NormalLineLength , IsPolyLine , IsCollisionBox ) ;
				if( !( result == 0 ) ) { throw new DX.Exception(); }
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1DrawModelDebug( int MHandle , COLOR_U8 Color , bool IsNormalLine , float NormalLineLength , bool IsPolyLine , bool IsCollisionBox ) ;


		/// <summary> モデルのローカル座標からワールド座標に変換する行列を得る </summary>
		public static MATRIX MV1GetLocalWorldMatrix( Model MHandle )
		{
			lock( locker )
			{
				MATRIX result = dx_MV1GetLocalWorldMatrix( Model.ToHandle( MHandle ) ) ;
				return result ;
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern MATRIX dx_MV1GetLocalWorldMatrix( int MHandle ) ;


		/// <summary> モデルの座標をセット </summary>
		public static void MV1SetPosition( Model MHandle , VECTOR Position )
		{
			lock( locker )
			{
				int result = dx_MV1SetPosition( Model.ToHandle( MHandle ) , Position ) ;
				if( !( result == 0 ) ) { throw new DX.Exception(); }
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1SetPosition( int MHandle , VECTOR Position ) ;


		/// <summary> モデルの座標を取得 </summary>
		public static VECTOR MV1GetPosition( Model MHandle )
		{
			lock( locker )
			{
				VECTOR result = dx_MV1GetPosition( Model.ToHandle( MHandle ) ) ;
				return result ;
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern VECTOR dx_MV1GetPosition( int MHandle ) ;


		/// <summary> モデルの拡大値をセット </summary>
		public static void MV1SetScale( Model MHandle , VECTOR Scale )
		{
			lock( locker )
			{
				int result = dx_MV1SetScale( Model.ToHandle( MHandle ) , Scale ) ;
				if( !( result == 0 ) ) { throw new DX.Exception(); }
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1SetScale( int MHandle , VECTOR Scale ) ;


		/// <summary> モデルの拡大値を取得 </summary>
		public static VECTOR MV1GetScale( Model MHandle )
		{
			lock( locker )
			{
				VECTOR result = dx_MV1GetScale( Model.ToHandle( MHandle ) ) ;
				return result ;
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern VECTOR dx_MV1GetScale( int MHandle ) ;


		/// <summary> モデルの回転値をセット( Ｘ軸回転→Ｙ軸回転→Ｚ軸回転方式 ) </summary>
		public static void MV1SetRotationXYZ( Model MHandle , VECTOR Rotate )
		{
			lock( locker )
			{
				int result = dx_MV1SetRotationXYZ( Model.ToHandle( MHandle ) , Rotate ) ;
				if( !( result == 0 ) ) { throw new DX.Exception(); }
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1SetRotationXYZ( int MHandle , VECTOR Rotate ) ;


		/// <summary> モデルの回転値を取得( Ｘ軸回転→Ｙ軸回転→Ｚ軸回転方式 ) </summary>
		public static VECTOR MV1GetRotationXYZ( Model MHandle )
		{
			lock( locker )
			{
				VECTOR result = dx_MV1GetRotationXYZ( Model.ToHandle( MHandle ) ) ;
				return result ;
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern VECTOR dx_MV1GetRotationXYZ( int MHandle ) ;


		/// <summary> モデルのＺ軸とＹ軸の向きをセットする </summary>
		public static void MV1SetRotationZYAxis( Model MHandle , VECTOR ZAxisDirection , VECTOR YAxisDirection , float ZAxisTwistRotate )
		{
			lock( locker )
			{
				int result = dx_MV1SetRotationZYAxis( Model.ToHandle( MHandle ) , ZAxisDirection , YAxisDirection , ZAxisTwistRotate ) ;
				if( !( result == 0 ) ) { throw new DX.Exception(); }
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1SetRotationZYAxis( int MHandle , VECTOR ZAxisDirection , VECTOR YAxisDirection , float ZAxisTwistRotate ) ;


		/// <summary> モデルの回転用行列をセットする </summary>
		public static void MV1SetRotationMatrix( Model MHandle , MATRIX Matrix )
		{
			lock( locker )
			{
				int result = dx_MV1SetRotationMatrix( Model.ToHandle( MHandle ) , Matrix ) ;
				if( !( result == 0 ) ) { throw new DX.Exception(); }
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1SetRotationMatrix( int MHandle , MATRIX Matrix ) ;


		/// <summary> モデルの回転用行列を取得する </summary>
		public static MATRIX MV1GetRotationMatrix( Model MHandle )
		{
			lock( locker )
			{
				MATRIX result = dx_MV1GetRotationMatrix( Model.ToHandle( MHandle ) ) ;
				return result ;
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern MATRIX dx_MV1GetRotationMatrix( int MHandle ) ;


		/// <summary> モデルの変形用行列をセットする </summary>
		public static void MV1SetMatrix( Model MHandle , MATRIX Matrix )
		{
			lock( locker )
			{
				int result = dx_MV1SetMatrix( Model.ToHandle( MHandle ) , Matrix ) ;
				if( !( result == 0 ) ) { throw new DX.Exception(); }
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1SetMatrix( int MHandle , MATRIX Matrix ) ;


		/// <summary> モデルの変形用行列を取得する </summary>
		public static MATRIX MV1GetMatrix( Model MHandle )
		{
			lock( locker )
			{
				MATRIX result = dx_MV1GetMatrix( Model.ToHandle( MHandle ) ) ;
				return result ;
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern MATRIX dx_MV1GetMatrix( int MHandle ) ;


		/// <summary> モデルの表示、非表示状態を変更する( TRUE:表示  FALSE:非表示 ) </summary>
		public static void MV1SetVisible( Model MHandle , bool VisibleFlag )
		{
			lock( locker )
			{
				int result = dx_MV1SetVisible( Model.ToHandle( MHandle ) , VisibleFlag ) ;
				if( !( result == 0 ) ) { throw new DX.Exception(); }
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1SetVisible( int MHandle , bool VisibleFlag ) ;


		/// <summary> モデルの表示、非表示状態を取得する( TRUE:表示  FALSE:非表示 ) </summary>
		public static bool MV1GetVisible( Model MHandle )
		{
			lock( locker )
			{
				int result = dx_MV1GetVisible( Model.ToHandle( MHandle ) ) ;
				if( result == 0 ) { return false ; }
				else if( result == 1 ) { return true ; }
				else { throw new DX.Exception() ; }
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1GetVisible( int MHandle ) ;


		/// <summary> モデルのディフューズカラーのスケール値を設定する( デフォルト値は 1.0f ) </summary>
		public static void MV1SetDifColorScale( Model MHandle , COLOR_F Scale )
		{
			lock( locker )
			{
				int result = dx_MV1SetDifColorScale( Model.ToHandle( MHandle ) , Scale ) ;
				if( !( result == 0 ) ) { throw new DX.Exception(); }
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1SetDifColorScale( int MHandle , COLOR_F Scale ) ;


		/// <summary> モデルのディフューズカラーのスケール値を取得する( デフォルト値は 1.0f ) </summary>
		public static COLOR_F MV1GetDifColorScale( Model MHandle )
		{
			lock( locker )
			{
				COLOR_F result = dx_MV1GetDifColorScale( Model.ToHandle( MHandle ) ) ;
				return result ;
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern COLOR_F dx_MV1GetDifColorScale( int MHandle ) ;


		/// <summary> モデルのスペキュラカラーのスケール値を設定する( デフォルト値は 1.0f ) </summary>
		public static void MV1SetSpcColorScale( Model MHandle , COLOR_F Scale )
		{
			lock( locker )
			{
				int result = dx_MV1SetSpcColorScale( Model.ToHandle( MHandle ) , Scale ) ;
				if( !( result == 0 ) ) { throw new DX.Exception(); }
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1SetSpcColorScale( int MHandle , COLOR_F Scale ) ;


		/// <summary> モデルのスペキュラカラーのスケール値を取得する( デフォルト値は 1.0f ) </summary>
		public static COLOR_F MV1GetSpcColorScale( Model MHandle )
		{
			lock( locker )
			{
				COLOR_F result = dx_MV1GetSpcColorScale( Model.ToHandle( MHandle ) ) ;
				return result ;
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern COLOR_F dx_MV1GetSpcColorScale( int MHandle ) ;


		/// <summary> モデルのエミッシブカラーのスケール値を設定する( デフォルト値は 1.0f ) </summary>
		public static void MV1SetEmiColorScale( Model MHandle , COLOR_F Scale )
		{
			lock( locker )
			{
				int result = dx_MV1SetEmiColorScale( Model.ToHandle( MHandle ) , Scale ) ;
				if( !( result == 0 ) ) { throw new DX.Exception(); }
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1SetEmiColorScale( int MHandle , COLOR_F Scale ) ;


		/// <summary> モデルのエミッシブカラーのスケール値を取得する( デフォルト値は 1.0f ) </summary>
		public static COLOR_F MV1GetEmiColorScale( Model MHandle )
		{
			lock( locker )
			{
				COLOR_F result = dx_MV1GetEmiColorScale( Model.ToHandle( MHandle ) ) ;
				return result ;
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern COLOR_F dx_MV1GetEmiColorScale( int MHandle ) ;


		/// <summary> モデルのアンビエントカラーのスケール値を設定する( デフォルト値は 1.0f ) </summary>
		public static void MV1SetAmbColorScale( Model MHandle , COLOR_F Scale )
		{
			lock( locker )
			{
				int result = dx_MV1SetAmbColorScale( Model.ToHandle( MHandle ) , Scale ) ;
				if( !( result == 0 ) ) { throw new DX.Exception(); }
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1SetAmbColorScale( int MHandle , COLOR_F Scale ) ;


		/// <summary> モデルのアンビエントカラーのスケール値を取得する( デフォルト値は 1.0f ) </summary>
		public static COLOR_F MV1GetAmbColorScale( Model MHandle )
		{
			lock( locker )
			{
				COLOR_F result = dx_MV1GetAmbColorScale( Model.ToHandle( MHandle ) ) ;
				return result ;
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern COLOR_F dx_MV1GetAmbColorScale( int MHandle ) ;


		/// <summary> モデルに半透明要素があるかどうかを取得する( 戻り値 TRUE:ある  FALSE:ない ) </summary>
		public static bool MV1GetSemiTransState( Model MHandle )
		{
			lock( locker )
			{
				int result = dx_MV1GetSemiTransState( Model.ToHandle( MHandle ) ) ;
				if( result == 0 ) { return false ; }
				else if( result == 1 ) { return true ; }
				else { throw new DX.Exception() ; }
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1GetSemiTransState( int MHandle ) ;


		/// <summary> モデルの不透明度を設定する( 不透明 1.0f 〜 透明 0.0f ) </summary>
		public static void MV1SetOpacityRate( Model MHandle , float Rate )
		{
			lock( locker )
			{
				int result = dx_MV1SetOpacityRate( Model.ToHandle( MHandle ) , Rate ) ;
				if( !( result == 0 ) ) { throw new DX.Exception(); }
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1SetOpacityRate( int MHandle , float Rate ) ;


		/// <summary> モデルの不透明度を取得する( 不透明 1.0f 〜 透明 0.0f ) </summary>
		public static float MV1GetOpacityRate( Model MHandle )
		{
			lock( locker )
			{
				float result = dx_MV1GetOpacityRate( Model.ToHandle( MHandle ) ) ;
				return result ;
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern float dx_MV1GetOpacityRate( int MHandle ) ;


		/// <summary> モデルを描画する際にＺバッファを使用するかどうかを設定する </summary>
		public static void MV1SetUseZBuffer( Model MHandle , bool Flag )
		{
			lock( locker )
			{
				int result = dx_MV1SetUseZBuffer( Model.ToHandle( MHandle ) , Flag ) ;
				if( !( result == 0 ) ) { throw new DX.Exception(); }
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1SetUseZBuffer( int MHandle , bool Flag ) ;


		/// <summary> モデルを描画する際にＺバッファに書き込みを行うかどうかを設定する </summary>
		public static void MV1SetWriteZBuffer( Model MHandle , bool Flag )
		{
			lock( locker )
			{
				int result = dx_MV1SetWriteZBuffer( Model.ToHandle( MHandle ) , Flag ) ;
				if( !( result == 0 ) ) { throw new DX.Exception(); }
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1SetWriteZBuffer( int MHandle , bool Flag ) ;


		/// <summary> モデルの描画時のＺ値の比較モードを設定する </summary>
		/// <param name="CmpType">  DX_CMP_NEVER 等 </param>
		public static void MV1SetZBufferCmpType( Model MHandle , DX_CMP CmpType )
		{
			lock( locker )
			{
				int result = dx_MV1SetZBufferCmpType( Model.ToHandle( MHandle ) , CmpType ) ;
				if( !( result == 0 ) ) { throw new DX.Exception(); }
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1SetZBufferCmpType( int MHandle , DX_CMP CmpType ) ;


		/// <summary> モデルの描画時の書き込むＺ値のバイアスを設定する </summary>
		public static void MV1SetZBias( Model MHandle , int Bias )
		{
			lock( locker )
			{
				int result = dx_MV1SetZBias( Model.ToHandle( MHandle ) , Bias ) ;
				if( !( result == 0 ) ) { throw new DX.Exception(); }
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1SetZBias( int MHandle , int Bias ) ;


		/// <summary> モデルの含まれるメッシュの頂点ディフューズカラーをマテリアルのディフューズカラーの代わりに使用するかどうかを設定する( TRUE:マテリアルカラーの代わりに使用する  FALSE:マテリアルカラーを使用する ) </summary>
		public static void MV1SetUseVertDifColor( Model MHandle , bool UseFlag )
		{
			lock( locker )
			{
				int result = dx_MV1SetUseVertDifColor( Model.ToHandle( MHandle ) , UseFlag ) ;
				if( !( result == 0 ) ) { throw new DX.Exception(); }
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1SetUseVertDifColor( int MHandle , bool UseFlag ) ;


		/// <summary> モデルに含まれるメッシュの頂点スペキュラカラーをマテリアルのスペキュラカラーの代わりに使用するかどうかを設定する( TRUE:マテリアルカラーの代わりに使用する  FALSE:マテリアルカラーを使用する ) </summary>
		public static void MV1SetUseVertSpcColor( Model MHandle , bool UseFlag )
		{
			lock( locker )
			{
				int result = dx_MV1SetUseVertSpcColor( Model.ToHandle( MHandle ) , UseFlag ) ;
				if( !( result == 0 ) ) { throw new DX.Exception(); }
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1SetUseVertSpcColor( int MHandle , bool UseFlag ) ;


		/// <summary> モデルのテクスチャのサンプルフィルターモードを変更する( FilterMode は DX_DRAWMODE_NEAREST 等 ) </summary>
		public static void MV1SetSampleFilterMode( Model MHandle , DX_DRAWMODE FilterMode )
		{
			lock( locker )
			{
				int result = dx_MV1SetSampleFilterMode( Model.ToHandle( MHandle ) , FilterMode ) ;
				if( !( result == 0 ) ) { throw new DX.Exception(); }
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1SetSampleFilterMode( int MHandle , DX_DRAWMODE FilterMode ) ;


		/// <summary> モデルの異方性フィルタリングの最大次数を設定する </summary>
		public static void MV1SetMaxAnisotropy( Model MHandle , int MaxAnisotropy )
		{
			lock( locker )
			{
				int result = dx_MV1SetMaxAnisotropy( Model.ToHandle( MHandle ) , MaxAnisotropy ) ;
				if( !( result == 0 ) ) { throw new DX.Exception(); }
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1SetMaxAnisotropy( int MHandle , int MaxAnisotropy ) ;


		/// <summary> アニメーションをアタッチする( 戻り値  -1:エラー  0以上:アタッチインデックス ) </summary>
		public static int MV1AttachAnim( Model MHandle , int AnimIndex )
		{
			return MV1AttachAnim( MHandle , AnimIndex , null , true ) ;
		}

		/// <summary> アニメーションをアタッチする( 戻り値  -1:エラー  0以上:アタッチインデックス ) </summary>
		public static int MV1AttachAnim( Model MHandle , int AnimIndex , Model AnimSrcMHandle )
		{
			return MV1AttachAnim( MHandle , AnimIndex , AnimSrcMHandle , true ) ;
		}

		/// <summary> アニメーションをアタッチする( 戻り値  -1:エラー  0以上:アタッチインデックス ) </summary>
		public static int MV1AttachAnim( Model MHandle , int AnimIndex , Model AnimSrcMHandle , bool NameCheck )
		{
			lock( locker )
			{
				int result = dx_MV1AttachAnim( Model.ToHandle( MHandle ) , AnimIndex , Model.ToHandle( AnimSrcMHandle ) , NameCheck ) ;
				if( !( result >= 0 ) ) { throw new DX.Exception(); }
				return result ;
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1AttachAnim( int MHandle , int AnimIndex , int AnimSrcMHandle , bool NameCheck ) ;


		/// <summary> アニメーションをデタッチする </summary>
		public static void MV1DetachAnim( Model MHandle , int AttachIndex )
		{
			lock( locker )
			{
				int result = dx_MV1DetachAnim( Model.ToHandle( MHandle ) , AttachIndex ) ;
				if( !( result == 0 ) ) { throw new DX.Exception(); }
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1DetachAnim( int MHandle , int AttachIndex ) ;


		/// <summary> アタッチしているアニメーションの再生時間を設定する </summary>
		public static void MV1SetAttachAnimTime( Model MHandle , int AttachIndex , float Time )
		{
			lock( locker )
			{
				int result = dx_MV1SetAttachAnimTime( Model.ToHandle( MHandle ) , AttachIndex , Time ) ;
				if( !( result == 0 ) ) { throw new DX.Exception(); }
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1SetAttachAnimTime( int MHandle , int AttachIndex , float Time ) ;


		/// <summary> アタッチしているアニメーションの再生時間を取得する </summary>
		public static float MV1GetAttachAnimTime( Model MHandle , int AttachIndex )
		{
			lock( locker )
			{
				float result = dx_MV1GetAttachAnimTime( Model.ToHandle( MHandle ) , AttachIndex ) ;
				return result ;
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern float dx_MV1GetAttachAnimTime( int MHandle , int AttachIndex ) ;


		/// <summary> アタッチしているアニメーションの総時間を得る </summary>
		public static float MV1GetAttachAnimTotalTime( Model MHandle , int AttachIndex )
		{
			lock( locker )
			{
				float result = dx_MV1GetAttachAnimTotalTime( Model.ToHandle( MHandle ) , AttachIndex ) ;
				return result ;
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern float dx_MV1GetAttachAnimTotalTime( int MHandle , int AttachIndex ) ;


		/// <summary> アタッチしているアニメーションのブレンド率を設定する </summary>
		public static void MV1SetAttachAnimBlendRate( Model MHandle , int AttachIndex )
		{
			lock( locker )
			{
				MV1SetAttachAnimBlendRate( MHandle , AttachIndex , 1.0f ) ;
			}
		}

		/// <summary> アタッチしているアニメーションのブレンド率を設定する </summary>
		public static void MV1SetAttachAnimBlendRate( Model MHandle , int AttachIndex , float Rate )
		{
			lock( locker )
			{
				int result = dx_MV1SetAttachAnimBlendRate( Model.ToHandle( MHandle ) , AttachIndex , Rate ) ;
				if( !( result == 0 ) ) { throw new DX.Exception(); }
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1SetAttachAnimBlendRate( int MHandle , int AttachIndex , float Rate ) ;


		/// <summary> アタッチしているアニメーションのブレンド率を取得する </summary>
		public static float MV1GetAttachAnimBlendRate( Model MHandle , int AttachIndex )
		{
			lock( locker )
			{
				float result = dx_MV1GetAttachAnimBlendRate( Model.ToHandle( MHandle ) , AttachIndex ) ;
				return result ;
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern float dx_MV1GetAttachAnimBlendRate( int MHandle , int AttachIndex ) ;


		/// <summary> アタッチしているアニメーションのブレンド率を設定する( フレーム単位 ) </summary>
		public static void MV1SetAttachAnimBlendRateToFrame( Model MHandle , int AttachIndex , int FrameIndex , float Rate , bool SetChild )
		{
			lock( locker )
			{
				int result = dx_MV1SetAttachAnimBlendRateToFrame( Model.ToHandle( MHandle ) , AttachIndex , FrameIndex , Rate , SetChild ) ;
				if( !( result == 0 ) ) { throw new DX.Exception(); }
			}
		}

		/// <summary> アタッチしているアニメーションのブレンド率を設定する( フレーム単位 ) </summary>
		public static void MV1SetAttachAnimBlendRateToFrame( Model MHandle , int AttachIndex , int FrameIndex , float Rate )
		{
			MV1SetAttachAnimBlendRateToFrame( MHandle , AttachIndex , FrameIndex , Rate , true ) ;
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1SetAttachAnimBlendRateToFrame( int MHandle , int AttachIndex , int FrameIndex , float Rate , bool SetChild ) ;


		/// <summary> アタッチしているアニメーションのブレンド率を設定する( フレーム単位 ) </summary>
		public static float MV1GetAttachAnimBlendRateToFrame( Model MHandle , int AttachIndex , int FrameIndex )
		{
			lock( locker )
			{
				float result = dx_MV1GetAttachAnimBlendRateToFrame( Model.ToHandle( MHandle ) , AttachIndex , FrameIndex ) ;
				return result ;
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern float dx_MV1GetAttachAnimBlendRateToFrame( int MHandle , int AttachIndex , int FrameIndex ) ;


		/// <summary> アタッチしているアニメーションのアニメーションインデックスを取得する </summary>
		public static int MV1GetAttachAnim( Model MHandle , int AttachIndex )
		{
			lock( locker )
			{
				int result = dx_MV1GetAttachAnim( Model.ToHandle( MHandle ) , AttachIndex ) ;
				if( !( result >= 0 ) ) { throw new DX.Exception(); }
				return result ;
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1GetAttachAnim( int MHandle , int AttachIndex ) ;


		/// <summary> アニメーションの数を取得する </summary>
		public static int MV1GetAnimNum( Model MHandle )
		{
			lock( locker )
			{
				int result = dx_MV1GetAnimNum( Model.ToHandle( MHandle ) ) ;
				if( !( result >= 0 ) ) { throw new DX.Exception(); }
				return result ;
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1GetAnimNum( int MHandle ) ;


		/// <summary> 指定番号のアニメーション名を取得する( NULL:エラー ) </summary>
		public static string MV1GetAnimName( Model MHandle , int AnimIndex )
		{
			lock( locker )
			{
				IntPtr result = dx_MV1GetAnimName( Model.ToHandle( MHandle ) , AnimIndex ) ;
				if( !( result != IntPtr.Zero ) ) { throw new DX.Exception(); }
			#if UNICODE
				return Marshal.PtrToStringUni( result ) ;
			#else
				return Marshal.PtrToStringAnsi( result ) ;
			#endif
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern IntPtr dx_MV1GetAnimName( int MHandle , int AnimIndex ) ;


		/// <summary> 指定名のアニメーション番号を取得する( -1:エラー ) </summary>
		public static int MV1GetAnimIndex( Model MHandle , string AnimName )
		{
			lock( locker )
			{
				int result = dx_MV1GetAnimIndex( Model.ToHandle( MHandle ) , AnimName ) ;
				if( !( result >= 0 ) ) { throw new DX.Exception(); }
				return result ;
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1GetAnimIndex( int MHandle , string AnimName ) ;


		/// <summary> 指定番号のアニメーションの総時間を得る </summary>
		public static float MV1GetAnimTotalTime( Model MHandle , int AnimIndex )
		{
			lock( locker )
			{
				float result = dx_MV1GetAnimTotalTime( Model.ToHandle( MHandle ) , AnimIndex ) ;
				return result ;
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern float dx_MV1GetAnimTotalTime( int MHandle , int AnimIndex ) ;


		/// <summary> 指定のアニメーションがターゲットとするフレームの数を取得する </summary>
		public static int MV1GetAnimTargetFrameNum( Model MHandle , int AnimIndex )
		{
			lock( locker )
			{
				int result = dx_MV1GetAnimTargetFrameNum( Model.ToHandle( MHandle ) , AnimIndex ) ;
				if( !( result >= 0 ) ) { throw new DX.Exception(); }
				return result ;
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1GetAnimTargetFrameNum( int MHandle , int AnimIndex ) ;


		/// <summary> 指定のアニメーションがターゲットとするフレームの名前を取得する </summary>
		public static string MV1GetAnimTargetFrameName( Model MHandle , int AnimIndex , int AnimFrameIndex )
		{
			lock( locker )
			{
				IntPtr result = dx_MV1GetAnimTargetFrameName( Model.ToHandle( MHandle ) , AnimIndex , AnimFrameIndex ) ;
				if( !( result != IntPtr.Zero ) ) { throw new DX.Exception(); }
			#if UNICODE
				return Marshal.PtrToStringUni( result ) ;
			#else
				return Marshal.PtrToStringAnsi( result ) ;
			#endif
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern IntPtr dx_MV1GetAnimTargetFrameName( int MHandle , int AnimIndex , int AnimFrameIndex ) ;


		/// <summary> 指定のアニメーションがターゲットとするフレームの番号を取得する </summary>
		public static int MV1GetAnimTargetFrame( Model MHandle , int AnimIndex , int AnimFrameIndex )
		{
			lock( locker )
			{
				int result = dx_MV1GetAnimTargetFrame( Model.ToHandle( MHandle ) , AnimIndex , AnimFrameIndex ) ;
				if( !( result >= 0 ) ) { throw new DX.Exception(); }
				return result ;
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1GetAnimTargetFrame( int MHandle , int AnimIndex , int AnimFrameIndex ) ;


		/// <summary> 指定のアニメーションがターゲットとするフレーム用のアニメーションキーセットの数を取得する </summary>
		public static int MV1GetAnimTargetFrameKeySetNum( Model MHandle , int AnimIndex , int AnimFrameIndex )
		{
			lock( locker )
			{
				int result = dx_MV1GetAnimTargetFrameKeySetNum( Model.ToHandle( MHandle ) , AnimIndex , AnimFrameIndex ) ;
				if( !( result >= 0 ) ) { throw new DX.Exception(); }
				return result ;
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1GetAnimTargetFrameKeySetNum( int MHandle , int AnimIndex , int AnimFrameIndex ) ;


		/// <summary> 指定のアニメーションがターゲットとするフレーム用のアニメーションキーセットキーセットインデックスを取得する </summary>
		public static int MV1GetAnimTargetFrameKeySet( Model MHandle , int AnimIndex , int AnimFrameIndex , int Index )
		{
			lock( locker )
			{
				int result = dx_MV1GetAnimTargetFrameKeySet( Model.ToHandle( MHandle ) , AnimIndex , AnimFrameIndex , Index ) ;
				if( !( result >= 0 ) ) { throw new DX.Exception(); }
				return result ;
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1GetAnimTargetFrameKeySet( int MHandle , int AnimIndex , int AnimFrameIndex , int Index ) ;


		/// <summary> モデルに含まれるアニメーションキーセットの総数を得る </summary>
		public static int MV1GetAnimKeySetNum( Model MHandle )
		{
			lock( locker )
			{
				int result = dx_MV1GetAnimKeySetNum( Model.ToHandle( MHandle ) ) ;
				if( !( result >= 0 ) ) { throw new DX.Exception(); }
				return result ;
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1GetAnimKeySetNum( int MHandle ) ;


		/// <summary> 指定のアニメーションキーセットのタイプを取得する( MV1_ANIMKEY_TYPE_QUATERNION 等 ) </summary>
		public static MV1_ANIMKEY_TYPE MV1GetAnimKeySetType( Model MHandle , int AnimKeySetIndex )
		{
			lock( locker )
			{
				MV1_ANIMKEY_TYPE result = dx_MV1GetAnimKeySetType( Model.ToHandle( MHandle ) , AnimKeySetIndex ) ;
				return result ;
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern MV1_ANIMKEY_TYPE dx_MV1GetAnimKeySetType( int MHandle , int AnimKeySetIndex ) ;


		/// <summary> 指定のアニメーションキーセットのデータタイプを取得する( MV1_ANIMKEY_DATATYPE_ROTATE 等 ) </summary>
		public static MV1_ANIMKEY_DATATYPE MV1GetAnimKeySetDataType( int MHandle , int AnimKeySetIndex )
		{
			lock( locker )
			{
				MV1_ANIMKEY_DATATYPE result = dx_MV1GetAnimKeySetDataType( MHandle , AnimKeySetIndex ) ;
				return result ;
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern MV1_ANIMKEY_DATATYPE dx_MV1GetAnimKeySetDataType( int MHandle , int AnimKeySetIndex ) ;


		/// <summary> 指定のアニメーションキーセットのキーの時間データタイプを取得する( MV1_ANIMKEY_TIME_TYPE_ONE 等 ) </summary>
		public static MV1_ANIMKEY_TIME_TYPE MV1GetAnimKeySetTimeType( Model MHandle , int AnimKeySetIndex )
		{
			lock( locker )
			{
				MV1_ANIMKEY_TIME_TYPE result = dx_MV1GetAnimKeySetTimeType( Model.ToHandle( MHandle ) , AnimKeySetIndex ) ;
				return result ;
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern MV1_ANIMKEY_TIME_TYPE dx_MV1GetAnimKeySetTimeType( int MHandle , int AnimKeySetIndex ) ;


		/// <summary> 指定のアニメーションキーセットのキーの数を取得する </summary>
		public static int MV1GetAnimKeySetDataNum( Model MHandle , int AnimKeySetIndex )
		{
			lock( locker )
			{
				int result = dx_MV1GetAnimKeySetDataNum( Model.ToHandle( MHandle ) , AnimKeySetIndex ) ;
				if( !( result >= 0 ) ) { throw new DX.Exception(); }
				return result ;
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1GetAnimKeySetDataNum( int MHandle , int AnimKeySetIndex ) ;


		/// <summary> 指定のアニメーションキーセットのキーの時間を取得する </summary>
		public static float MV1GetAnimKeyDataTime( Model MHandle , int AnimKeySetIndex , int Index )
		{
			lock( locker )
			{
				float result = dx_MV1GetAnimKeyDataTime( Model.ToHandle( MHandle ) , AnimKeySetIndex , Index ) ;
				return result ;
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern float dx_MV1GetAnimKeyDataTime( int MHandle , int AnimKeySetIndex , int Index ) ;


		/// <summary> 指定のアニメーションキーセットのキーを取得する、キータイプが MV1_ANIMKEY_TYPE_QUATERNION では無かった場合は失敗する </summary>
		public static FLOAT4 MV1GetAnimKeyDataToQuaternion( Model MHandle , int AnimKeySetIndex , int Index )
		{
			lock( locker )
			{
				FLOAT4 result = dx_MV1GetAnimKeyDataToQuaternion( Model.ToHandle( MHandle ) , AnimKeySetIndex , Index ) ;
				return result ;
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern FLOAT4 dx_MV1GetAnimKeyDataToQuaternion( int MHandle , int AnimKeySetIndex , int Index ) ;


		/// <summary> 指定のアニメーションキーセットのキーを取得する、キータイプが MV1_ANIMKEY_TYPE_VECTOR では無かった場合は失敗する </summary>
		public static VECTOR MV1GetAnimKeyDataToVector( Model MHandle , int AnimKeySetIndex , int Index )
		{
			lock( locker )
			{
				VECTOR result = dx_MV1GetAnimKeyDataToVector( Model.ToHandle( MHandle ) , AnimKeySetIndex , Index ) ;
				return result ;
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern VECTOR dx_MV1GetAnimKeyDataToVector( int MHandle , int AnimKeySetIndex , int Index ) ;


		/// <summary> 指定のアニメーションキーセットのキーを取得する、キータイプが MV1_ANIMKEY_TYPE_MATRIX4X4C か MV1_ANIMKEY_TYPE_MATRIX3X3 では無かった場合は失敗する </summary>
		public static MATRIX MV1GetAnimKeyDataToMatrix( Model MHandle , int AnimKeySetIndex , int Index )
		{
			lock( locker )
			{
				MATRIX result = dx_MV1GetAnimKeyDataToMatrix( Model.ToHandle( MHandle ) , AnimKeySetIndex , Index ) ;
				return result ;
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern MATRIX dx_MV1GetAnimKeyDataToMatrix( int MHandle , int AnimKeySetIndex , int Index ) ;


		/// <summary> 指定のアニメーションキーセットのキーを取得する、キータイプが MV1_ANIMKEY_TYPE_FLAT では無かった場合は失敗する </summary>
		public static float MV1GetAnimKeyDataToFlat( Model MHandle , int AnimKeySetIndex , int Index )
		{
			lock( locker )
			{
				float result = dx_MV1GetAnimKeyDataToFlat( Model.ToHandle( MHandle ) , AnimKeySetIndex , Index ) ;
				return result ;
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern float dx_MV1GetAnimKeyDataToFlat( int MHandle , int AnimKeySetIndex , int Index ) ;


		/// <summary> 指定のアニメーションキーセットのキーを取得する、キータイプが MV1_ANIMKEY_TYPE_LINEAR では無かった場合は失敗する </summary>
		public static float MV1GetAnimKeyDataToLinear( Model MHandle , int AnimKeySetIndex , int Index )
		{
			lock( locker )
			{
				float result = dx_MV1GetAnimKeyDataToLinear( Model.ToHandle( MHandle ) , AnimKeySetIndex , Index ) ;
				return result ;
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern float dx_MV1GetAnimKeyDataToLinear( int MHandle , int AnimKeySetIndex , int Index ) ;


		/// <summary> モデルで使用しているマテリアルの数を取得する </summary>
		public static int MV1GetMaterialNum( Model MHandle )
		{
			lock( locker )
			{
				int result = dx_MV1GetMaterialNum( Model.ToHandle( MHandle ) ) ;
				if( !( result >= 0 ) ) { throw new DX.Exception(); }
				return result ;
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1GetMaterialNum( int MHandle ) ;


		/// <summary> 指定のマテリアルの名前を取得する </summary>
		public static string MV1GetMaterialName( int MHandle , int MaterialIndex )
		{
			lock( locker )
			{
				IntPtr result = dx_MV1GetMaterialName( MHandle , MaterialIndex ) ;
				if( !( result != IntPtr.Zero ) ) { throw new DX.Exception(); }
			#if UNICODE
				return Marshal.PtrToStringUni( result ) ;
			#else
				return Marshal.PtrToStringAnsi( result ) ;
			#endif
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern IntPtr dx_MV1GetMaterialName( int MHandle , int MaterialIndex ) ;


		/// <summary> 指定のマテリアルのタイプを変更する( Type : DX_MATERIAL_TYPE_NORMAL など ) </summary>
		public static void MV1SetMaterialType( Model MHandle , int MaterialIndex , DX_MATERIAL_TYPE Type )
		{
			lock( locker )
			{
				int result = dx_MV1SetMaterialType( Model.ToHandle( MHandle ) , MaterialIndex , Type ) ;
				if( !( result == 0 ) ) { throw new DX.Exception(); }
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1SetMaterialType( int MHandle , int MaterialIndex , DX_MATERIAL_TYPE Type ) ;


		/// <summary> 指定のマテリアルのタイプを取得する( 戻り値 : DX_MATERIAL_TYPE_NORMAL など ) </summary>
		public static DX_MATERIAL_TYPE MV1GetMaterialType( Model MHandle , int MaterialIndex )
		{
			lock( locker )
			{
				DX_MATERIAL_TYPE result = dx_MV1GetMaterialType( Model.ToHandle( MHandle ) , MaterialIndex ) ;
				return result ;
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern DX_MATERIAL_TYPE dx_MV1GetMaterialType( int MHandle , int MaterialIndex ) ;


		/// <summary> 指定のマテリアルのディフューズカラーを設定する </summary>
		public static void MV1SetMaterialDifColor( Model MHandle , int MaterialIndex , COLOR_F Color )
		{
			lock( locker )
			{
				int result = dx_MV1SetMaterialDifColor( Model.ToHandle( MHandle ) , MaterialIndex , Color ) ;
				if( !( result == 0 ) ) { throw new DX.Exception(); }
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1SetMaterialDifColor( int MHandle , int MaterialIndex , COLOR_F Color ) ;


		/// <summary> 指定のマテリアルのディフューズカラーを取得する </summary>
		public static COLOR_F MV1GetMaterialDifColor( Model MHandle , int MaterialIndex )
		{
			lock( locker )
			{
				COLOR_F result = dx_MV1GetMaterialDifColor( Model.ToHandle( MHandle ) , MaterialIndex ) ;
				return result ;
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern COLOR_F dx_MV1GetMaterialDifColor( int MHandle , int MaterialIndex ) ;


		/// <summary> 指定のマテリアルのスペキュラカラーを設定する </summary>
		public static void MV1SetMaterialSpcColor( Model MHandle , int MaterialIndex , COLOR_F Color )
		{
			lock( locker )
			{
				int result = dx_MV1SetMaterialSpcColor( Model.ToHandle( MHandle ) , MaterialIndex , Color ) ;
				if( !( result == 0 ) ) { throw new DX.Exception(); }
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1SetMaterialSpcColor( int MHandle , int MaterialIndex , COLOR_F Color ) ;


		/// <summary> 指定のマテリアルのスペキュラカラーを取得する </summary>
		public static COLOR_F MV1GetMaterialSpcColor( Model MHandle , int MaterialIndex )
		{
			lock( locker )
			{
				COLOR_F result = dx_MV1GetMaterialSpcColor( Model.ToHandle( MHandle ) , MaterialIndex ) ;
				return result ;
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern COLOR_F dx_MV1GetMaterialSpcColor( int MHandle , int MaterialIndex ) ;


		/// <summary> 指定のマテリアルのエミッシブカラーを設定する </summary>
		public static void MV1SetMaterialEmiColor( Model MHandle , int MaterialIndex , COLOR_F Color )
		{
			lock( locker )
			{
				int result = dx_MV1SetMaterialEmiColor( Model.ToHandle( MHandle ) , MaterialIndex , Color ) ;
				if( !( result == 0 ) ) { throw new DX.Exception(); }
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1SetMaterialEmiColor( int MHandle , int MaterialIndex , COLOR_F Color ) ;


		/// <summary> 指定のマテリアルのエミッシブカラーを取得する </summary>
		public static COLOR_F MV1GetMaterialEmiColor( Model MHandle , int MaterialIndex )
		{
			lock( locker )
			{
				COLOR_F result = dx_MV1GetMaterialEmiColor( Model.ToHandle( MHandle ) , MaterialIndex ) ;
				return result ;
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern COLOR_F dx_MV1GetMaterialEmiColor( int MHandle , int MaterialIndex ) ;


		/// <summary> 指定のマテリアルのアンビエントカラーを設定する </summary>
		public static void MV1SetMaterialAmbColor( Model MHandle , int MaterialIndex , COLOR_F Color )
		{
			lock( locker )
			{
				int result = dx_MV1SetMaterialAmbColor( Model.ToHandle( MHandle ) , MaterialIndex , Color ) ;
				if( !( result == 0 ) ) { throw new DX.Exception(); }
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1SetMaterialAmbColor( int MHandle , int MaterialIndex , COLOR_F Color ) ;


		/// <summary> 指定のマテリアルのアンビエントカラーを取得する </summary>
		public static COLOR_F MV1GetMaterialAmbColor( Model MHandle , int MaterialIndex )
		{
			lock( locker )
			{
				COLOR_F result = dx_MV1GetMaterialAmbColor( Model.ToHandle( MHandle ) , MaterialIndex ) ;
				return result ;
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern COLOR_F dx_MV1GetMaterialAmbColor( int MHandle , int MaterialIndex ) ;


		/// <summary> 指定のマテリアルのスペキュラの強さを設定する </summary>
		public static void MV1SetMaterialSpcPower( Model MHandle , int MaterialIndex , float Power )
		{
			lock( locker )
			{
				int result = dx_MV1SetMaterialSpcPower( Model.ToHandle( MHandle ) , MaterialIndex , Power ) ;
				if( !( result == 0 ) ) { throw new DX.Exception(); }
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1SetMaterialSpcPower( int MHandle , int MaterialIndex , float Power ) ;


		/// <summary> 指定のマテリアルのスペキュラの強さを取得する </summary>
		public static float MV1GetMaterialSpcPower( Model MHandle , int MaterialIndex )
		{
			lock( locker )
			{
				float result = dx_MV1GetMaterialSpcPower( Model.ToHandle( MHandle ) , MaterialIndex ) ;
				return result ;
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern float dx_MV1GetMaterialSpcPower( int MHandle , int MaterialIndex ) ;


		/// <summary> 指定のマテリアルでディフューズマップとして使用するテクスチャを指定する </summary>
		public static void MV1SetMaterialDifMapTexture( Model MHandle , int MaterialIndex , int TexIndex )
		{
			lock( locker )
			{
				int result = dx_MV1SetMaterialDifMapTexture( Model.ToHandle( MHandle ) , MaterialIndex , TexIndex ) ;
				if( !( result == 0 ) ) { throw new DX.Exception(); }
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1SetMaterialDifMapTexture( int MHandle , int MaterialIndex , int TexIndex ) ;


		/// <summary> 指定のマテリアルでディフューズマップとして使用されているテクスチャのインデックスを取得する </summary>
		public static int MV1GetMaterialDifMapTexture( Model MHandle , int MaterialIndex )
		{
			lock( locker )
			{
				int result = dx_MV1GetMaterialDifMapTexture( Model.ToHandle( MHandle ) , MaterialIndex ) ;
				if( !( result >= 0 ) ) { throw new DX.Exception(); }
				return result ;
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1GetMaterialDifMapTexture( int MHandle , int MaterialIndex ) ;


		/// <summary> 指定のマテリアルでスペキュラマップとして使用するテクスチャを指定する </summary>
		public static void MV1SetMaterialSpcMapTexture( Model MHandle , int MaterialIndex , int TexIndex )
		{
			lock( locker )
			{
				int result = dx_MV1SetMaterialSpcMapTexture( Model.ToHandle( MHandle ) , MaterialIndex , TexIndex ) ;
				if( !( result == 0 ) ) { throw new DX.Exception(); }
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1SetMaterialSpcMapTexture( int MHandle , int MaterialIndex , int TexIndex ) ;


		/// <summary> 指定のマテリアルでスペキュラマップとして使用されているテクスチャのインデックスを取得する </summary>
		public static int MV1GetMaterialSpcMapTexture( Model MHandle , int MaterialIndex )
		{
			lock( locker )
			{
				int result = dx_MV1GetMaterialSpcMapTexture( Model.ToHandle( MHandle ) , MaterialIndex ) ;
				if( !( result >= 0 ) ) { throw new DX.Exception(); }
				return result ;
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1GetMaterialSpcMapTexture( int MHandle , int MaterialIndex ) ;


		/// <summary> 指定のマテリアルで法線マップとして使用されているテクスチャのインデックスを取得する </summary>
		public static int MV1GetMaterialNormalMapTexture( Model MHandle , int MaterialIndex )
		{
			lock( locker )
			{
				int result = dx_MV1GetMaterialNormalMapTexture( Model.ToHandle( MHandle ) , MaterialIndex ) ;
				if( !( result >= 0 ) ) { throw new DX.Exception(); }
				return result ;
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1GetMaterialNormalMapTexture( int MHandle , int MaterialIndex ) ;


		/// <summary> 指定のマテリアルでトゥーンレンダリングのディフューズグラデーションマップとして使用するテクスチャを設定する </summary>
		public static void MV1SetMaterialDifGradTexture( Model MHandle , int MaterialIndex , int TexIndex )
		{
			lock( locker )
			{
				int result = dx_MV1SetMaterialDifGradTexture( Model.ToHandle( MHandle ) , MaterialIndex , TexIndex ) ;
				if( !( result == 0 ) ) { throw new DX.Exception(); }
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1SetMaterialDifGradTexture( int MHandle , int MaterialIndex , int TexIndex ) ;


		/// <summary> 指定のマテリアルでトゥーンレンダリングのディフューズグラデーションマップとして使用するテクスチャを取得する </summary>
		public static int MV1GetMaterialDifGradTexture( Model MHandle , int MaterialIndex )
		{
			lock( locker )
			{
				int result = dx_MV1GetMaterialDifGradTexture( Model.ToHandle( MHandle ) , MaterialIndex ) ;
				if( !( result >= 0 ) ) { throw new DX.Exception(); }
				return result ;
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1GetMaterialDifGradTexture( int MHandle , int MaterialIndex ) ;


		/// <summary> 指定のマテリアルでトゥーンレンダリングのスペキュラグラデーションマップとして使用するテクスチャを設定する </summary>
		public static void MV1SetMaterialSpcGradTexture( Model MHandle , int MaterialIndex , int TexIndex )
		{
			lock( locker )
			{
				int result = dx_MV1SetMaterialSpcGradTexture( Model.ToHandle( MHandle ) , MaterialIndex , TexIndex ) ;
				if( !( result == 0 ) ) { throw new DX.Exception(); }
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1SetMaterialSpcGradTexture( int MHandle , int MaterialIndex , int TexIndex ) ;


		/// <summary> 指定のマテリアルでトゥーンレンダリングのスペキュラグラデーションマップとして使用するテクスチャを取得する </summary>
		public static int MV1GetMaterialSpcGradTexture( Model MHandle , int MaterialIndex )
		{
			lock( locker )
			{
				int result = dx_MV1GetMaterialSpcGradTexture( Model.ToHandle( MHandle ) , MaterialIndex ) ;
				if( !( result >= 0 ) ) { throw new DX.Exception(); }
				return result ;
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1GetMaterialSpcGradTexture( int MHandle , int MaterialIndex ) ;


		/// <summary> 指定のマテリアルのトゥーンレンダリングで使用するディフューズグラデーションマップとディフューズカラーの合成方法を設定する( DX_MATERIAL_BLENDTYPE_ADDITIVE など ) </summary>
		public static void MV1SetMaterialDifGradBlendType( Model MHandle , int MaterialIndex , DX_MATERIAL_BLENDTYPE BlendType )
		{
			lock( locker )
			{
				int result = dx_MV1SetMaterialDifGradBlendType( Model.ToHandle( MHandle ) , MaterialIndex , BlendType ) ;
				if( !( result == 0 ) ) { throw new DX.Exception(); }
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1SetMaterialDifGradBlendType( int MHandle , int MaterialIndex , DX_MATERIAL_BLENDTYPE BlendType ) ;


		/// <summary> 指定のマテリアルのトゥーンレンダリングで使用するディフューズグラデーションマップとディフューズカラーの合成方法を取得する( DX_MATERIAL_BLENDTYPE_ADDITIVE など ) </summary>
		public static DX_MATERIAL_BLENDTYPE MV1GetMaterialDifGradBlendType( Model MHandle , int MaterialIndex )
		{
			lock( locker )
			{
				DX_MATERIAL_BLENDTYPE result = dx_MV1GetMaterialDifGradBlendType( Model.ToHandle( MHandle ) , MaterialIndex ) ;
				return result ;
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern DX_MATERIAL_BLENDTYPE dx_MV1GetMaterialDifGradBlendType( int MHandle , int MaterialIndex ) ;


		/// <summary> 指定のマテリアルのトゥーンレンダリングで使用するスペキュラグラデーションマップとスペキュラカラーの合成方法を設定する( DX_MATERIAL_BLENDTYPE_ADDITIVE など ) </summary>
		public static void MV1SetMaterialSpcGradBlendType( Model MHandle , int MaterialIndex , DX_MATERIAL_BLENDTYPE BlendType )
		{
			lock( locker )
			{
				int result = dx_MV1SetMaterialSpcGradBlendType( Model.ToHandle( MHandle ) , MaterialIndex , BlendType ) ;
				if( !( result == 0 ) ) { throw new DX.Exception(); }
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1SetMaterialSpcGradBlendType( int MHandle , int MaterialIndex , DX_MATERIAL_BLENDTYPE BlendType ) ;


		/// <summary> 指定のマテリアルのトゥーンレンダリングで使用するスペキュラグラデーションマップとスペキュラカラーの合成方法を取得する( DX_MATERIAL_BLENDTYPE_ADDITIVE など ) </summary>
		public static DX_MATERIAL_BLENDTYPE MV1GetMaterialSpcGradBlendType( Model MHandle , int MaterialIndex )
		{
			lock( locker )
			{
				DX_MATERIAL_BLENDTYPE result = dx_MV1GetMaterialSpcGradBlendType( Model.ToHandle( MHandle ) , MaterialIndex ) ;
				return result ;
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern DX_MATERIAL_BLENDTYPE dx_MV1GetMaterialSpcGradBlendType( int MHandle , int MaterialIndex ) ;


		/// <summary> 指定のマテリアルのトゥーンレンダリングで使用する輪郭線の太さを設定する( 0.0f 〜 1.0f ) </summary>
		public static void MV1SetMaterialOutLineWidth( Model MHandle , int MaterialIndex , float Width )
		{
			lock( locker )
			{
				int result = dx_MV1SetMaterialOutLineWidth( Model.ToHandle( MHandle ) , MaterialIndex , Width ) ;
				if( !( result == 0 ) ) { throw new DX.Exception(); }
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1SetMaterialOutLineWidth( int MHandle , int MaterialIndex , float Width ) ;


		/// <summary> 指定のマテリアルのトゥーンレンダリングで使用する輪郭線の太さを取得する( 0.0f 〜 1.0f ) </summary>
		public static float MV1GetMaterialOutLineWidth( Model MHandle , int MaterialIndex )
		{
			lock( locker )
			{
				float result = dx_MV1GetMaterialOutLineWidth( Model.ToHandle( MHandle ) , MaterialIndex ) ;
				return result ;
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern float dx_MV1GetMaterialOutLineWidth( int MHandle , int MaterialIndex ) ;


		/// <summary> 指定のマテリアルのトゥーンレンダリングで使用する輪郭線の色を設定する </summary>
		public static void MV1SetMaterialOutLineColor( Model MHandle , int MaterialIndex , COLOR_F Color )
		{
			lock( locker )
			{
				int result = dx_MV1SetMaterialOutLineColor( Model.ToHandle( MHandle ) , MaterialIndex , Color ) ;
				if( !( result == 0 ) ) { throw new DX.Exception(); }
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1SetMaterialOutLineColor( int MHandle , int MaterialIndex , COLOR_F Color ) ;


		/// <summary> 指定のマテリアルのトゥーンレンダリングで使用する輪郭線の色を取得する </summary>
		public static COLOR_F MV1GetMaterialOutLineColor( Model MHandle , int MaterialIndex )
		{
			lock( locker )
			{
				COLOR_F result = dx_MV1GetMaterialOutLineColor( Model.ToHandle( MHandle ) , MaterialIndex ) ;
				return result ;
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern COLOR_F dx_MV1GetMaterialOutLineColor( int MHandle , int MaterialIndex ) ;


		/// <summary> 指定のマテリアルの描画ブレンドモードを設定する( DX_BLENDMODE_ALPHA 等 ) </summary>
		public static void MV1SetMaterialDrawBlendMode( Model MHandle , int MaterialIndex , DX_BLENDMODE BlendMode )
		{
			lock( locker )
			{
				int result = dx_MV1SetMaterialDrawBlendMode( Model.ToHandle( MHandle ) , MaterialIndex , BlendMode ) ;
				if( !( result == 0 ) ) { throw new DX.Exception(); }
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1SetMaterialDrawBlendMode( int MHandle , int MaterialIndex , DX_BLENDMODE BlendMode ) ;


		/// <summary> 指定のマテリアルの描画ブレンドモードを取得する( DX_BLENDMODE_ALPHA 等 ) </summary>
		public static DX_BLENDMODE MV1GetMaterialDrawBlendMode( Model MHandle , int MaterialIndex )
		{
			lock( locker )
			{
				DX_BLENDMODE result = dx_MV1GetMaterialDrawBlendMode( Model.ToHandle( MHandle ) , MaterialIndex ) ;
				return result ;
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern DX_BLENDMODE dx_MV1GetMaterialDrawBlendMode( int MHandle , int MaterialIndex ) ;


		/// <summary> 指定のマテリアルの描画ブレンドパラメータを設定する </summary>
		public static void MV1SetMaterialDrawBlendParam( Model MHandle , int MaterialIndex , int BlendParam )
		{
			lock( locker )
			{
				int result = dx_MV1SetMaterialDrawBlendParam( Model.ToHandle( MHandle ) , MaterialIndex , BlendParam ) ;
				if( !( result == 0 ) ) { throw new DX.Exception(); }
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1SetMaterialDrawBlendParam( int MHandle , int MaterialIndex , int BlendParam ) ;


		/// <summary> 指定のマテリアルの描画ブレンドパラメータを設定する </summary>
		public static int MV1GetMaterialDrawBlendParam( Model MHandle , int MaterialIndex )
		{
			lock( locker )
			{
				int result = dx_MV1GetMaterialDrawBlendParam( Model.ToHandle( MHandle ) , MaterialIndex ) ;
				if( !( result >= 0 ) ) { throw new DX.Exception(); }
				return result ;
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1GetMaterialDrawBlendParam( int MHandle , int MaterialIndex ) ;


		/// <summary> テクスチャの数を取得 </summary>
		public static int MV1GetTextureNum( Model MHandle )
		{
			lock( locker )
			{
				int result = dx_MV1GetTextureNum( Model.ToHandle( MHandle ) ) ;
				if( !( result >= 0 ) ) { throw new DX.Exception(); }
				return result ;
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1GetTextureNum( int MHandle ) ;


		/// <summary> テクスチャの名前を取得 </summary>
		public static string MV1GetTextureName( Model MHandle , int TexIndex )
		{
			lock( locker )
			{
				IntPtr result = dx_MV1GetTextureName( Model.ToHandle( MHandle ) , TexIndex ) ;
				if( !( result != IntPtr.Zero ) ) { throw new DX.Exception(); }
			#if UNICODE
				return Marshal.PtrToStringUni( result ) ;
			#else
				return Marshal.PtrToStringAnsi( result ) ;
			#endif
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern IntPtr dx_MV1GetTextureName( int MHandle , int TexIndex ) ;


		/// <summary> カラーテクスチャのファイルパスを変更する </summary>
		public static void MV1SetTextureColorFilePath( Model MHandle , int TexIndex , string FilePath )
		{
			lock( locker )
			{
				int result = dx_MV1SetTextureColorFilePath( Model.ToHandle( MHandle ) , TexIndex , FilePath ) ;
				if( !( result == 0 ) ) { throw new DX.Exception(); }
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1SetTextureColorFilePath( int MHandle , int TexIndex , string FilePath ) ;


		/// <summary> カラーテクスチャのファイルパスを取得 </summary>
		public static string MV1GetTextureColorFilePath( Model MHandle , int TexIndex )
		{
			lock( locker )
			{
				IntPtr result = dx_MV1GetTextureColorFilePath( Model.ToHandle( MHandle ) , TexIndex ) ;
				if( !( result != IntPtr.Zero ) ) { throw new DX.Exception(); }
			#if UNICODE
				return Marshal.PtrToStringUni( result ) ;
			#else
				return Marshal.PtrToStringAnsi( result ) ;
			#endif
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern IntPtr dx_MV1GetTextureColorFilePath( int MHandle , int TexIndex ) ;


		/// <summary> アルファテクスチャのファイルパスを変更する </summary>
		public static void MV1SetTextureAlphaFilePath( Model MHandle , int TexIndex , string FilePath )
		{
			lock( locker )
			{
				int result = dx_MV1SetTextureAlphaFilePath( Model.ToHandle( MHandle ) , TexIndex , FilePath ) ;
				if( !( result == 0 ) ) { throw new DX.Exception(); }
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1SetTextureAlphaFilePath( int MHandle , int TexIndex , string FilePath ) ;


		/// <summary> アルファテクスチャのファイルパスを取得 </summary>
		public static string MV1GetTextureAlphaFilePath( Model MHandle , int TexIndex )
		{
			lock( locker )
			{
				IntPtr result = dx_MV1GetTextureAlphaFilePath( Model.ToHandle( MHandle ) , TexIndex ) ;
				if( !( result != IntPtr.Zero ) ) { throw new DX.Exception(); }
			#if UNICODE
				return Marshal.PtrToStringUni( result ) ;
			#else
				return Marshal.PtrToStringAnsi( result ) ;
			#endif
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern IntPtr dx_MV1GetTextureAlphaFilePath( int MHandle , int TexIndex ) ;


		/// <summary> テクスチャで使用するグラフィックハンドルを変更する( GrHandle を -1 にすると解除 ) </summary>
		public static void MV1SetTextureGraphHandle( Model MHandle , int TexIndex , Graph GrHandle , bool SemiTransFlag )
		{
			lock( locker )
			{
				int result = dx_MV1SetTextureGraphHandle( Model.ToHandle( MHandle ) , TexIndex , Graph.ToHandle( GrHandle ) , SemiTransFlag ) ;
				if( !( result == 0 ) ) { throw new DX.Exception(); }
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1SetTextureGraphHandle( int MHandle , int TexIndex , int GrHandle , bool SemiTransFlag ) ;


		/// <summary> テクスチャのグラフィックハンドルを取得する </summary>
		public static Graph MV1GetTextureGraphHandle( Model MHandle , int TexIndex )
		{
			lock( locker )
			{
				int result = dx_MV1GetTextureGraphHandle( Model.ToHandle( MHandle ) , TexIndex ) ;
				if( !( result != -1 ) ) { throw new DX.Exception(); }
				return Graph.FromHandle( result ) ;
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1GetTextureGraphHandle( int MHandle , int TexIndex ) ;


		/// <summary> テクスチャのアドレスモードを設定する( AddUMode の値は DX_TEXADDRESS_WRAP 等 ) </summary>
		public static void MV1SetTextureAddressMode( Model MHandle , int TexIndex , DX_TEXADDRESS AddrUMode , DX_TEXADDRESS AddrVMode )
		{
			lock( locker )
			{
				int result = dx_MV1SetTextureAddressMode( Model.ToHandle( MHandle ) , TexIndex , AddrUMode , AddrVMode ) ;
				if( !( result == 0 ) ) { throw new DX.Exception(); }
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1SetTextureAddressMode( int MHandle , int TexIndex , DX_TEXADDRESS AddrUMode , DX_TEXADDRESS AddrVMode ) ;


		/// <summary> テクスチャのＵ値のアドレスモードを取得する( 戻り値:DX_TEXADDRESS_WRAP 等 ) </summary>
		public static DX_TEXADDRESS MV1GetTextureAddressModeU( Model MHandle , int TexIndex )
		{
			lock( locker )
			{
				DX_TEXADDRESS result = dx_MV1GetTextureAddressModeU( Model.ToHandle( MHandle ) , TexIndex ) ;
				return result ;
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern DX_TEXADDRESS dx_MV1GetTextureAddressModeU( int MHandle , int TexIndex ) ;


		/// <summary> テクスチャのＶ値のアドレスモードを取得する( 戻り値:DX_TEXADDRESS_WRAP 等 ) </summary>
		public static DX_TEXADDRESS MV1GetTextureAddressModeV( Model MHandle , int TexIndex )
		{
			lock( locker )
			{
				DX_TEXADDRESS result = dx_MV1GetTextureAddressModeV( Model.ToHandle( MHandle ) , TexIndex ) ;
				return result ;
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern DX_TEXADDRESS dx_MV1GetTextureAddressModeV( int MHandle , int TexIndex ) ;


		/// <summary> テクスチャの幅を取得する </summary>
		public static int MV1GetTextureWidth( Model MHandle , int TexIndex )
		{
			lock( locker )
			{
				int result = dx_MV1GetTextureWidth( Model.ToHandle( MHandle ) , TexIndex ) ;
				if( !( result >= 0 ) ) { throw new DX.Exception(); }
				return result ;
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1GetTextureWidth( int MHandle , int TexIndex ) ;


		/// <summary> テクスチャの高さを取得する </summary>
		public static int MV1GetTextureHeight( Model MHandle , int TexIndex )
		{
			lock( locker )
			{
				int result = dx_MV1GetTextureHeight( Model.ToHandle( MHandle ) , TexIndex ) ;
				if( !( result >= 0 ) ) { throw new DX.Exception(); }
				return result ;
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1GetTextureHeight( int MHandle , int TexIndex ) ;


		/// <summary> テクスチャに半透明要素があるかどうかを取得する( 戻り値  TRUE:ある  FALSE:ない ) </summary>
		public static bool MV1GetTextureSemiTransState( Model MHandle , int TexIndex )
		{
			lock( locker )
			{
				int result = dx_MV1GetTextureSemiTransState( Model.ToHandle( MHandle ) , TexIndex ) ;
				if( result == 0 ) { return false ; }
				else if( result == 1 ) { return true ; }
				else { throw new DX.Exception() ; }
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1GetTextureSemiTransState( int MHandle , int TexIndex ) ;


		/// <summary> テクスチャで使用している画像がバンプマップかどうかを設定する </summary>
		public static void MV1SetTextureBumpImageFlag( Model MHandle , int TexIndex , bool Flag )
		{
			lock( locker )
			{
				int result = dx_MV1SetTextureBumpImageFlag( Model.ToHandle( MHandle ) , TexIndex , Flag ) ;
				if( !( result == 0 ) ) { throw new DX.Exception(); }
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1SetTextureBumpImageFlag( int MHandle , int TexIndex , bool Flag ) ;


		/// <summary> テクスチャがバンプマップかどうかを取得する( 戻り値  TRUE:バンプマップ  FALSE:違う ) </summary>
		public static bool MV1GetTextureBumpImageFlag( Model MHandle , int TexIndex )
		{
			lock( locker )
			{
				int result = dx_MV1GetTextureBumpImageFlag( Model.ToHandle( MHandle ) , TexIndex ) ;
				if( result == 0 ) { return false ; }
				else if( result == 1 ) { return true ; }
				else { throw new DX.Exception() ; }
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1GetTextureBumpImageFlag( int MHandle , int TexIndex ) ;


		/// <summary> バンプマップ画像の場合の隣のピクセルとの距離を設定する </summary>
		public static void MV1SetTextureBumpImageNextPixelLength( Model MHandle , int TexIndex , float Length )
		{
			lock( locker )
			{
				int result = dx_MV1SetTextureBumpImageNextPixelLength( Model.ToHandle( MHandle ) , TexIndex , Length ) ;
				if( !( result == 0 ) ) { throw new DX.Exception(); }
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1SetTextureBumpImageNextPixelLength( int MHandle , int TexIndex , float Length ) ;


		/// <summary> バンプマップ画像の場合の隣のピクセルとの距離を取得する </summary>
		public static float MV1GetTextureBumpImageNextPixelLength( Model MHandle , int TexIndex )
		{
			lock( locker )
			{
				float result = dx_MV1GetTextureBumpImageNextPixelLength( Model.ToHandle( MHandle ) , TexIndex ) ;
				return result ;
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern float dx_MV1GetTextureBumpImageNextPixelLength( int MHandle , int TexIndex ) ;


		/// <summary> テクスチャのフィルタリングモードを設定する </summary>
		public static void MV1SetTextureSampleFilterMode( Model MHandle , int TexIndex , DX_DRAWMODE FilterMode )
		{
			lock( locker )
			{
				int result = dx_MV1SetTextureSampleFilterMode( Model.ToHandle( MHandle ) , TexIndex , FilterMode ) ;
				if( !( result == 0 ) ) { throw new DX.Exception(); }
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1SetTextureSampleFilterMode( int MHandle , int TexIndex , DX_DRAWMODE FilterMode ) ;


		/// <summary> テクスチャのフィルタリングモードを取得する( 戻り値  DX_DRAWMODE_BILINEAR等 ) </summary>
		public static DX_DRAWMODE MV1GetTextureSampleFilterMode( Model MHandle , int TexIndex )
		{
			lock( locker )
			{
				DX_DRAWMODE result = dx_MV1GetTextureSampleFilterMode( Model.ToHandle( MHandle ) , TexIndex ) ;
				return result ;
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern DX_DRAWMODE dx_MV1GetTextureSampleFilterMode( int MHandle , int TexIndex ) ;


		/// <summary> フレームの数を取得する </summary>
		public static int MV1GetFrameNum( Model MHandle )
		{
			lock( locker )
			{
				int result = dx_MV1GetFrameNum( Model.ToHandle( MHandle ) ) ;
				if( !( result >= 0 ) ) { throw new DX.Exception(); }
				return result ;
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1GetFrameNum( int MHandle ) ;


		/// <summary> フレームの名前からモデル中のフレームのフレームインデックスを取得する( 無かった場合は戻り値が-1 ) </summary>
		public static int MV1SearchFrame( Model MHandle , string FrameName )
		{
			lock( locker )
			{
				int result = dx_MV1SearchFrame( Model.ToHandle( MHandle ) , FrameName ) ;
				return result ;
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1SearchFrame( int MHandle , string FrameName ) ;


		/// <summary> フレームの名前から指定のフレームの子フレームのフレームインデックスを取得する( 名前指定版 )( FrameIndex を -1 にすると親を持たないフレームを ChildIndex で指定する )( 無かった場合は戻り値が-1 ) </summary>
		public static int MV1SearchFrameChild( Model MHandle )
		{
			return MV1SearchFrameChild( MHandle , -1 ) ;
		}

		/// <summary> フレームの名前から指定のフレームの子フレームのフレームインデックスを取得する( 名前指定版 )( FrameIndex を -1 にすると親を持たないフレームを ChildIndex で指定する )( 無かった場合は戻り値が-1 ) </summary>
		public static int MV1SearchFrameChild( Model MHandle , int FrameIndex )
		{
			return MV1SearchFrameChild( MHandle , FrameIndex , null ) ;
		}

		/// <summary> フレームの名前から指定のフレームの子フレームのフレームインデックスを取得する( 名前指定版 )( FrameIndex を -1 にすると親を持たないフレームを ChildIndex で指定する )( 無かった場合は戻り値が-1 ) </summary>
		public static int MV1SearchFrameChild( Model MHandle , int FrameIndex , string ChildName )
		{
			lock( locker )
			{
				int result = dx_MV1SearchFrameChild( Model.ToHandle( MHandle ) , FrameIndex , ChildName ) ;
				return result ;
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1SearchFrameChild( int MHandle , int FrameIndex , string ChildName ) ;


		/// <summary> 指定のフレームの名前を取得する( エラーの場合は戻り値が NULL ) </summary>
		public static string MV1GetFrameName( Model MHandle , int FrameIndex )
		{
			lock( locker )
			{
				IntPtr result = dx_MV1GetFrameName( Model.ToHandle( MHandle ) , FrameIndex ) ;
				if( !( result != IntPtr.Zero ) ) { throw new DX.Exception(); }
			#if UNICODE
				return Marshal.PtrToStringUni( result ) ;
			#else
				return Marshal.PtrToStringAnsi( result ) ;
			#endif
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern IntPtr dx_MV1GetFrameName( int MHandle , int FrameIndex ) ;


		/// <summary> 指定のフレームの親フレームのインデックスを得る( 親がいない場合は -2 が返る ) </summary>
		public static int MV1GetFrameParent( Model MHandle , int FrameIndex )
		{
			lock( locker )
			{
				int result = dx_MV1GetFrameParent( Model.ToHandle( MHandle ) , FrameIndex ) ;
				return result ;
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1GetFrameParent( int MHandle , int FrameIndex ) ;


		/// <summary> 指定のフレームの子フレームの数を取得する( FrameIndex を -1 にすると親を持たないフレームの数が返ってくる ) </summary>
		public static int MV1GetFrameChildNum( Model MHandle )
		{
			return MV1GetFrameChildNum( MHandle , -1 ) ;
		}

		/// <summary> 指定のフレームの子フレームの数を取得する( FrameIndex を -1 にすると親を持たないフレームの数が返ってくる ) </summary>
		public static int MV1GetFrameChildNum( Model MHandle , int FrameIndex )
		{
			lock( locker )
			{
				int result = dx_MV1GetFrameChildNum( Model.ToHandle( MHandle ) , FrameIndex ) ;
				if( !( result >= 0 ) ) { throw new DX.Exception(); }
				return result ;
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1GetFrameChildNum( int MHandle , int FrameIndex ) ;


		/// <summary> 指定のフレームの子フレームのフレームインデックスを取得する( 番号指定版 )( FrameIndex を -1 にすると親を持たないフレームを ChildIndex で指定する )( エラーの場合は戻り値が-1 ) </summary>
		public static int MV1GetFrameChild( Model MHandle )
		{
			return MV1GetFrameChild( MHandle , -1 ) ;
		}

		/// <summary> 指定のフレームの子フレームのフレームインデックスを取得する( 番号指定版 )( FrameIndex を -1 にすると親を持たないフレームを ChildIndex で指定する )( エラーの場合は戻り値が-1 ) </summary>
		public static int MV1GetFrameChild( Model MHandle , int FrameIndex )
		{
			return MV1GetFrameChild( MHandle , FrameIndex , 0 ) ;
		}

		/// <summary> 指定のフレームの子フレームのフレームインデックスを取得する( 番号指定版 )( FrameIndex を -1 にすると親を持たないフレームを ChildIndex で指定する )( エラーの場合は戻り値が-1 ) </summary>
		public static int MV1GetFrameChild( Model MHandle , int FrameIndex , int ChildIndex )
		{
			lock( locker )
			{
				int result = dx_MV1GetFrameChild( Model.ToHandle( MHandle ) , FrameIndex , ChildIndex ) ;
				return result ;
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1GetFrameChild( int MHandle , int FrameIndex , int ChildIndex ) ;


		/// <summary> 指定のフレームの座標を取得する </summary>
		public static VECTOR MV1GetFramePosition( Model MHandle , int FrameIndex )
		{
			lock( locker )
			{
				VECTOR result = dx_MV1GetFramePosition( Model.ToHandle( MHandle ) , FrameIndex ) ;
				return result ;
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern VECTOR dx_MV1GetFramePosition( int MHandle , int FrameIndex ) ;


		/// <summary> 指定のフレームの初期状態での座標変換行列を取得する </summary>
		public static MATRIX MV1GetFrameBaseLocalMatrix( Model MHandle , int FrameIndex )
		{
			lock( locker )
			{
				MATRIX result = dx_MV1GetFrameBaseLocalMatrix( Model.ToHandle( MHandle ) , FrameIndex ) ;
				return result ;
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern MATRIX dx_MV1GetFrameBaseLocalMatrix( int MHandle , int FrameIndex ) ;


		/// <summary> 指定のフレームの座標変換行列を取得する </summary>
		public static MATRIX MV1GetFrameLocalMatrix( Model MHandle , int FrameIndex )
		{
			lock( locker )
			{
				MATRIX result = dx_MV1GetFrameLocalMatrix( Model.ToHandle( MHandle ) , FrameIndex ) ;
				return result ;
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern MATRIX dx_MV1GetFrameLocalMatrix( int MHandle , int FrameIndex ) ;


		/// <summary> 指定のフレームのローカル座標からワールド座標に変換する行列を得る </summary>
		public static MATRIX MV1GetFrameLocalWorldMatrix( Model MHandle , int FrameIndex )
		{
			lock( locker )
			{
				MATRIX result = dx_MV1GetFrameLocalWorldMatrix( Model.ToHandle( MHandle ) , FrameIndex ) ;
				return result ;
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern MATRIX dx_MV1GetFrameLocalWorldMatrix( int MHandle , int FrameIndex ) ;


		/// <summary> 指定のフレームの座標変換行列を設定する </summary>
		public static void MV1SetFrameUserLocalMatrix( Model MHandle , int FrameIndex , MATRIX Matrix )
		{
			lock( locker )
			{
				int result = dx_MV1SetFrameUserLocalMatrix( Model.ToHandle( MHandle ) , FrameIndex , Matrix ) ;
				if( !( result == 0 ) ) { throw new DX.Exception(); }
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1SetFrameUserLocalMatrix( int MHandle , int FrameIndex , MATRIX Matrix ) ;


		/// <summary> 指定のフレームの座標変換行列をデフォルトに戻す </summary>
		public static void MV1ResetFrameUserLocalMatrix( Model MHandle , int FrameIndex )
		{
			lock( locker )
			{
				int result = dx_MV1ResetFrameUserLocalMatrix( Model.ToHandle( MHandle ) , FrameIndex ) ;
				if( !( result == 0 ) ) { throw new DX.Exception(); }
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1ResetFrameUserLocalMatrix( int MHandle , int FrameIndex ) ;


		/// <summary> 指定のフレームが持つメッシュ頂点のローカル座標での最大値を得る </summary>
		public static VECTOR MV1GetFrameMaxVertexLocalPosition( Model MHandle , int FrameIndex )
		{
			lock( locker )
			{
				VECTOR result = dx_MV1GetFrameMaxVertexLocalPosition( Model.ToHandle( MHandle ) , FrameIndex ) ;
				return result ;
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern VECTOR dx_MV1GetFrameMaxVertexLocalPosition( int MHandle , int FrameIndex ) ;


		/// <summary> 指定のフレームが持つメッシュ頂点のローカル座標での最小値を得る </summary>
		public static VECTOR MV1GetFrameMinVertexLocalPosition( Model MHandle , int FrameIndex )
		{
			lock( locker )
			{
				VECTOR result = dx_MV1GetFrameMinVertexLocalPosition( Model.ToHandle( MHandle ) , FrameIndex ) ;
				return result ;
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern VECTOR dx_MV1GetFrameMinVertexLocalPosition( int MHandle , int FrameIndex ) ;


		/// <summary> 指定のフレームが持つメッシュ頂点のローカル座標での平均値を得る </summary>
		public static VECTOR MV1GetFrameAvgVertexLocalPosition( Model MHandle , int FrameIndex )
		{
			lock( locker )
			{
				VECTOR result = dx_MV1GetFrameAvgVertexLocalPosition( Model.ToHandle( MHandle ) , FrameIndex ) ;
				return result ;
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern VECTOR dx_MV1GetFrameAvgVertexLocalPosition( int MHandle , int FrameIndex ) ;


		/// <summary> 指定のフレームに含まれるポリゴンの数を取得する </summary>
		public static int MV1GetFrameTriangleNum( Model MHandle , int FrameIndex )
		{
			lock( locker )
			{
				int result = dx_MV1GetFrameTriangleNum( Model.ToHandle( MHandle ) , FrameIndex ) ;
				if( !( result >= 0 ) ) { throw new DX.Exception(); }
				return result ;
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1GetFrameTriangleNum( int MHandle , int FrameIndex ) ;


		/// <summary> 指定のフレームが持つメッシュの数を取得する </summary>
		public static int MV1GetFrameMeshNum( Model MHandle , int FrameIndex )
		{
			lock( locker )
			{
				int result = dx_MV1GetFrameMeshNum( Model.ToHandle( MHandle ) , FrameIndex ) ;
				if( !( result >= 0 ) ) { throw new DX.Exception(); }
				return result ;
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1GetFrameMeshNum( int MHandle , int FrameIndex ) ;


		/// <summary> 指定のフレームが持つメッシュのメッシュインデックスを取得する </summary>
		public static int MV1GetFrameMesh( Model MHandle , int FrameIndex , int Index )
		{
			lock( locker )
			{
				int result = dx_MV1GetFrameMesh( Model.ToHandle( MHandle ) , FrameIndex , Index ) ;
				if( !( result >= 0 ) ) { throw new DX.Exception(); }
				return result ;
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1GetFrameMesh( int MHandle , int FrameIndex , int Index ) ;


		/// <summary> 指定のフレームの表示、非表示状態を変更する( TRUE:表示  FALSE:非表示 ) </summary>
		public static void MV1SetFrameVisible( Model MHandle , int FrameIndex , bool VisibleFlag )
		{
			lock( locker )
			{
				int result = dx_MV1SetFrameVisible( Model.ToHandle( MHandle ) , FrameIndex , VisibleFlag ) ;
				if( !( result == 0 ) ) { throw new DX.Exception(); }
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1SetFrameVisible( int MHandle , int FrameIndex , bool VisibleFlag ) ;


		/// <summary> 指定のフレームの表示、非表示状態を取得する( TRUE:表示  FALSE:非表示 ) </summary>
		public static bool MV1GetFrameVisible( Model MHandle , int FrameIndex )
		{
			lock( locker )
			{
				int result = dx_MV1GetFrameVisible( Model.ToHandle( MHandle ) , FrameIndex ) ;
				if( result == 0 ) { return false ; }
				else if( result == 1 ) { return true ; }
				else { throw new DX.Exception() ; }
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1GetFrameVisible( int MHandle , int FrameIndex ) ;


		/// <summary> 指定のフレームのディフューズカラーのスケール値を設定する( デフォルト値は 1.0f ) </summary>
		public static void MV1SetFrameDifColorScale( Model MHandle , int FrameIndex , COLOR_F Scale )
		{
			lock( locker )
			{
				int result = dx_MV1SetFrameDifColorScale( Model.ToHandle( MHandle ) , FrameIndex , Scale ) ;
				if( !( result == 0 ) ) { throw new DX.Exception(); }
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1SetFrameDifColorScale( int MHandle , int FrameIndex , COLOR_F Scale ) ;


		/// <summary> 指定のフレームのスペキュラカラーのスケール値を設定する( デフォルト値は 1.0f ) </summary>
		public static void MV1SetFrameSpcColorScale( Model MHandle , int FrameIndex , COLOR_F Scale )
		{
			lock( locker )
			{
				int result = dx_MV1SetFrameSpcColorScale( Model.ToHandle( MHandle ) , FrameIndex , Scale ) ;
				if( !( result == 0 ) ) { throw new DX.Exception(); }
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1SetFrameSpcColorScale( int MHandle , int FrameIndex , COLOR_F Scale ) ;


		/// <summary> 指定のフレームのエミッシブカラーのスケール値を設定する( デフォルト値は 1.0f ) </summary>
		public static void MV1SetFrameEmiColorScale( Model MHandle , int FrameIndex , COLOR_F Scale )
		{
			lock( locker )
			{
				int result = dx_MV1SetFrameEmiColorScale( Model.ToHandle( MHandle ) , FrameIndex , Scale ) ;
				if( !( result == 0 ) ) { throw new DX.Exception(); }
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1SetFrameEmiColorScale( int MHandle , int FrameIndex , COLOR_F Scale ) ;


		/// <summary> 指定のフレームのアンビエントカラーのスケール値を設定する( デフォルト値は 1.0f ) </summary>
		public static void MV1SetFrameAmbColorScale( Model MHandle , int FrameIndex , COLOR_F Scale )
		{
			lock( locker )
			{
				int result = dx_MV1SetFrameAmbColorScale( Model.ToHandle( MHandle ) , FrameIndex , Scale ) ;
				if( !( result == 0 ) ) { throw new DX.Exception(); }
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1SetFrameAmbColorScale( int MHandle , int FrameIndex , COLOR_F Scale ) ;


		/// <summary> 指定のフレームのディフューズカラーのスケール値を取得する( デフォルト値は 1.0f ) </summary>
		public static COLOR_F MV1GetFrameDifColorScale( Model MHandle , int FrameIndex )
		{
			lock( locker )
			{
				COLOR_F result = dx_MV1GetFrameDifColorScale( Model.ToHandle( MHandle ) , FrameIndex ) ;
				return result ;
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern COLOR_F dx_MV1GetFrameDifColorScale( int MHandle , int FrameIndex ) ;


		/// <summary> 指定のフレームのスペキュラカラーのスケール値を取得する( デフォルト値は 1.0f ) </summary>
		public static COLOR_F MV1GetFrameSpcColorScale( Model MHandle , int FrameIndex )
		{
			lock( locker )
			{
				COLOR_F result = dx_MV1GetFrameSpcColorScale( Model.ToHandle( MHandle ) , FrameIndex ) ;
				return result ;
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern COLOR_F dx_MV1GetFrameSpcColorScale( int MHandle , int FrameIndex ) ;


		/// <summary> 指定のフレームのエミッシブカラーのスケール値を取得する( デフォルト値は 1.0f ) </summary>
		public static COLOR_F MV1GetFrameEmiColorScale( Model MHandle , int FrameIndex )
		{
			lock( locker )
			{
				COLOR_F result = dx_MV1GetFrameEmiColorScale( Model.ToHandle( MHandle ) , FrameIndex ) ;
				return result ;
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern COLOR_F dx_MV1GetFrameEmiColorScale( int MHandle , int FrameIndex ) ;


		/// <summary> 指定のフレームのアンビエントカラーのスケール値を取得する( デフォルト値は 1.0f ) </summary>
		public static COLOR_F MV1GetFrameAmbColorScale( Model MHandle , int FrameIndex )
		{
			lock( locker )
			{
				COLOR_F result = dx_MV1GetFrameAmbColorScale( Model.ToHandle( MHandle ) , FrameIndex ) ;
				return result ;
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern COLOR_F dx_MV1GetFrameAmbColorScale( int MHandle , int FrameIndex ) ;


		/// <summary> 指定のフレームに半透明要素があるかどうかを取得する( 戻り値 TRUE:ある  FALSE:ない ) </summary>
		public static bool MV1GetFrameSemiTransState( Model MHandle , int FrameIndex )
		{
			lock( locker )
			{
				int result = dx_MV1GetFrameSemiTransState( Model.ToHandle( MHandle ) , FrameIndex ) ;
				if( result == 0 ) { return false ; }
				else if( result == 1 ) { return true ; }
				else { throw new DX.Exception() ; }
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1GetFrameSemiTransState( int MHandle , int FrameIndex ) ;


		/// <summary> 指定のフレームの不透明度を設定する( 不透明 1.0f 〜 透明 0.0f ) </summary>
		public static void MV1SetFrameOpacityRate( Model MHandle , int FrameIndex , float Rate )
		{
			lock( locker )
			{
				int result = dx_MV1SetFrameOpacityRate( Model.ToHandle( MHandle ) , FrameIndex , Rate ) ;
				if( !( result == 0 ) ) { throw new DX.Exception(); }
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1SetFrameOpacityRate( int MHandle , int FrameIndex , float Rate ) ;


		/// <summary> 指定のフレームの不透明度を取得する( 不透明 1.0f 〜 透明 0.0f ) </summary>
		public static float MV1GetFrameOpacityRate( Model MHandle , int FrameIndex )
		{
			lock( locker )
			{
				float result = dx_MV1GetFrameOpacityRate( Model.ToHandle( MHandle ) , FrameIndex ) ;
				return result ;
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern float dx_MV1GetFrameOpacityRate( int MHandle , int FrameIndex ) ;


		/// <summary> 指定のフレームの初期表示状態を設定する( TRUE:表示  FALSE:非表示 ) </summary>
		public static void MV1SetFrameBaseVisible( Model MHandle , int FrameIndex , bool VisibleFlag )
		{
			lock( locker )
			{
				int result = dx_MV1SetFrameBaseVisible( Model.ToHandle( MHandle ) , FrameIndex , VisibleFlag ) ;
				if( !( result == 0 ) ) { throw new DX.Exception(); }
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1SetFrameBaseVisible( int MHandle , int FrameIndex , bool VisibleFlag ) ;


		/// <summary> 指定のフレームの初期表示状態を取得する( TRUE:表示  FALSE:非表示 ) </summary>
		public static bool MV1GetFrameBaseVisible( Model MHandle , int FrameIndex )
		{
			lock( locker )
			{
				int result = dx_MV1GetFrameBaseVisible( Model.ToHandle( MHandle ) , FrameIndex ) ;
				if( result == 0 ) { return false ; }
				else if( result == 1 ) { return true ; }
				else { throw new DX.Exception() ; }
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1GetFrameBaseVisible( int MHandle , int FrameIndex ) ;


		/// <summary> 指定のフレームのテクスチャ座標変換パラメータを設定する </summary>
		public static void MV1SetFrameTextureAddressTransform( Model MHandle , int FrameIndex , float TransU , float TransV , float ScaleU , float ScaleV , float RotCenterU , float RotCenterV , float Rotate )
		{
			lock( locker )
			{
				int result = dx_MV1SetFrameTextureAddressTransform( Model.ToHandle( MHandle ) , FrameIndex , TransU , TransV , ScaleU , ScaleV , RotCenterU , RotCenterV , Rotate ) ;
				if( !( result == 0 ) ) { throw new DX.Exception(); }
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1SetFrameTextureAddressTransform( int MHandle , int FrameIndex , float TransU , float TransV , float ScaleU , float ScaleV , float RotCenterU , float RotCenterV , float Rotate ) ;


		/// <summary> 指定のフレームのテクスチャ座標変換行列をセットする </summary>
		public static void MV1SetFrameTextureAddressTransformMatrix( Model MHandle , int FrameIndex , MATRIX Matrix )
		{
			lock( locker )
			{
				int result = dx_MV1SetFrameTextureAddressTransformMatrix( Model.ToHandle( MHandle ) , FrameIndex , Matrix ) ;
				if( !( result == 0 ) ) { throw new DX.Exception(); }
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1SetFrameTextureAddressTransformMatrix( int MHandle , int FrameIndex , MATRIX Matrix ) ;


		/// <summary> 指定のフレームのテクスチャ座標変換パラメータをリセットする </summary>
		public static void MV1ResetFrameTextureAddressTransform( Model MHandle , int FrameIndex )
		{
			lock( locker )
			{
				int result = dx_MV1ResetFrameTextureAddressTransform( Model.ToHandle( MHandle ) , FrameIndex ) ;
				if( !( result == 0 ) ) { throw new DX.Exception(); }
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1ResetFrameTextureAddressTransform( int MHandle , int FrameIndex ) ;


		/// <summary> モデルに含まれるメッシュの数を取得する </summary>
		public static int MV1GetMeshNum( Model MHandle )
		{
			lock( locker )
			{
				int result = dx_MV1GetMeshNum( Model.ToHandle( MHandle ) ) ;
				if( !( result >= 0 ) ) { throw new DX.Exception(); }
				return result ;
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1GetMeshNum( int MHandle ) ;


		/// <summary> 指定メッシュが使用しているマテリアルのインデックスを取得する </summary>
		public static int MV1GetMeshMaterial( Model MHandle , int MeshIndex )
		{
			lock( locker )
			{
				int result = dx_MV1GetMeshMaterial( Model.ToHandle( MHandle ) , MeshIndex ) ;
				if( !( result >= 0 ) ) { throw new DX.Exception(); }
				return result ;
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1GetMeshMaterial( int MHandle , int MeshIndex ) ;


		/// <summary> 指定メッシュに含まれる三角形ポリゴンの数を取得する </summary>
		public static int MV1GetMeshTriangleNum( Model MHandle , int MeshIndex )
		{
			lock( locker )
			{
				int result = dx_MV1GetMeshTriangleNum( Model.ToHandle( MHandle ) , MeshIndex ) ;
				if( !( result >= 0 ) ) { throw new DX.Exception(); }
				return result ;
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1GetMeshTriangleNum( int MHandle , int MeshIndex ) ;


		/// <summary> 指定メッシュの表示、非表示状態を変更する( TRUE:表示  FALSE:非表示 ) </summary>
		public static void MV1SetMeshVisible( Model MHandle , int MeshIndex , bool VisibleFlag )
		{
			lock( locker )
			{
				int result = dx_MV1SetMeshVisible( Model.ToHandle( MHandle ) , MeshIndex , VisibleFlag ) ;
				if( !( result == 0 ) ) { throw new DX.Exception(); }
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1SetMeshVisible( int MHandle , int MeshIndex , bool VisibleFlag ) ;


		/// <summary> 指定メッシュの表示、非表示状態を取得する( TRUE:表示  FALSE:非表示 ) </summary>
		public static bool MV1GetMeshVisible( Model MHandle , int MeshIndex )
		{
			lock( locker )
			{
				int result = dx_MV1GetMeshVisible( Model.ToHandle( MHandle ) , MeshIndex ) ;
				if( result == 0 ) { return false ; }
				else if( result == 1 ) { return true ; }
				else { throw new DX.Exception() ; }
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1GetMeshVisible( int MHandle , int MeshIndex ) ;


		/// <summary> 指定のメッシュのディフューズカラーのスケール値を設定する( デフォルト値は 1.0f ) </summary>
		public static void MV1SetMeshDifColorScale( Model MHandle , int MeshIndex , COLOR_F Scale )
		{
			lock( locker )
			{
				int result = dx_MV1SetMeshDifColorScale( Model.ToHandle( MHandle ) , MeshIndex , Scale ) ;
				if( !( result == 0 ) ) { throw new DX.Exception(); }
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1SetMeshDifColorScale( int MHandle , int MeshIndex , COLOR_F Scale ) ;


		/// <summary> 指定のメッシュのスペキュラカラーのスケール値を設定する( デフォルト値は 1.0f ) </summary>
		public static void MV1SetMeshSpcColorScale( Model MHandle , int MeshIndex , COLOR_F Scale )
		{
			lock( locker )
			{
				int result = dx_MV1SetMeshSpcColorScale( Model.ToHandle( MHandle ) , MeshIndex , Scale ) ;
				if( !( result == 0 ) ) { throw new DX.Exception(); }
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1SetMeshSpcColorScale( int MHandle , int MeshIndex , COLOR_F Scale ) ;


		/// <summary> 指定のメッシュのエミッシブカラーのスケール値を設定する( デフォルト値は 1.0f ) </summary>
		public static void MV1SetMeshEmiColorScale( Model MHandle , int MeshIndex , COLOR_F Scale )
		{
			lock( locker )
			{
				int result = dx_MV1SetMeshEmiColorScale( Model.ToHandle( MHandle ) , MeshIndex , Scale ) ;
				if( !( result == 0 ) ) { throw new DX.Exception(); }
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1SetMeshEmiColorScale( int MHandle , int MeshIndex , COLOR_F Scale ) ;


		/// <summary> 指定のメッシュのアンビエントカラーのスケール値を設定する( デフォルト値は 1.0f ) </summary>
		public static void MV1SetMeshAmbColorScale( Model MHandle , int MeshIndex , COLOR_F Scale )
		{
			lock( locker )
			{
				int result = dx_MV1SetMeshAmbColorScale( Model.ToHandle( MHandle ) , MeshIndex , Scale ) ;
				if( !( result == 0 ) ) { throw new DX.Exception(); }
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1SetMeshAmbColorScale( int MHandle , int MeshIndex , COLOR_F Scale ) ;


		/// <summary> 指定のメッシュのディフューズカラーのスケール値を取得する( デフォルト値は 1.0f ) </summary>
		public static COLOR_F MV1GetMeshDifColorScale( Model MHandle , int MeshIndex )
		{
			lock( locker )
			{
				COLOR_F result = dx_MV1GetMeshDifColorScale( Model.ToHandle( MHandle ) , MeshIndex ) ;
				return result ;
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern COLOR_F dx_MV1GetMeshDifColorScale( int MHandle , int MeshIndex ) ;


		/// <summary> 指定のメッシュのスペキュラカラーのスケール値を取得する( デフォルト値は 1.0f ) </summary>
		public static COLOR_F MV1GetMeshSpcColorScale( Model MHandle , int MeshIndex )
		{
			lock( locker )
			{
				COLOR_F result = dx_MV1GetMeshSpcColorScale( Model.ToHandle( MHandle ) , MeshIndex ) ;
				return result ;
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern COLOR_F dx_MV1GetMeshSpcColorScale( int MHandle , int MeshIndex ) ;


		/// <summary> 指定のメッシュのエミッシブカラーのスケール値を取得する( デフォルト値は 1.0f ) </summary>
		public static COLOR_F MV1GetMeshEmiColorScale( Model MHandle , int MeshIndex )
		{
			lock( locker )
			{
				COLOR_F result = dx_MV1GetMeshEmiColorScale( Model.ToHandle( MHandle ) , MeshIndex ) ;
				return result ;
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern COLOR_F dx_MV1GetMeshEmiColorScale( int MHandle , int MeshIndex ) ;


		/// <summary> 指定のメッシュのアンビエントカラーのスケール値を取得する( デフォルト値は 1.0f ) </summary>
		public static COLOR_F MV1GetMeshAmbColorScale( Model MHandle , int MeshIndex )
		{
			lock( locker )
			{
				COLOR_F result = dx_MV1GetMeshAmbColorScale( Model.ToHandle( MHandle ) , MeshIndex ) ;
				return result ;
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern COLOR_F dx_MV1GetMeshAmbColorScale( int MHandle , int MeshIndex ) ;


		/// <summary> 指定のメッシュの不透明度を設定する( 不透明 1.0f 〜 透明 0.0f ) </summary>
		public static void MV1SetMeshOpacityRate( Model MHandle , int MeshIndex , float Rate )
		{
			lock( locker )
			{
				int result = dx_MV1SetMeshOpacityRate( Model.ToHandle( MHandle ) , MeshIndex , Rate ) ;
				if( !( result == 0 ) ) { throw new DX.Exception(); }
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1SetMeshOpacityRate( int MHandle , int MeshIndex , float Rate ) ;


		/// <summary> 指定のメッシュの不透明度を取得する( 不透明 1.0f 〜 透明 0.0f ) </summary>
		public static float MV1GetMeshOpacityRate( Model MHandle , int MeshIndex )
		{
			lock( locker )
			{
				float result = dx_MV1GetMeshOpacityRate( Model.ToHandle( MHandle ) , MeshIndex ) ;
				return result ;
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern float dx_MV1GetMeshOpacityRate( int MHandle , int MeshIndex ) ;


		/// <summary> 指定のメッシュの描画ブレンドモードを設定する( DX_BLENDMODE_ALPHA 等 ) </summary>
		public static void MV1SetMeshDrawBlendMode( Model MHandle , int MeshIndex , DX_BLENDMODE BlendMode )
		{
			lock( locker )
			{
				int result = dx_MV1SetMeshDrawBlendMode( Model.ToHandle( MHandle ) , MeshIndex , BlendMode ) ;
				if( !( result == 0 ) ) { throw new DX.Exception(); }
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1SetMeshDrawBlendMode( int MHandle , int MeshIndex , DX_BLENDMODE BlendMode ) ;


		/// <summary> 指定のメッシュの描画ブレンドパラメータを設定する </summary>
		public static void MV1SetMeshDrawBlendParam( Model MHandle , int MeshIndex , int BlendParam )
		{
			lock( locker )
			{
				int result = dx_MV1SetMeshDrawBlendParam( Model.ToHandle( MHandle ) , MeshIndex , BlendParam ) ;
				if( !( result == 0 ) ) { throw new DX.Exception(); }
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1SetMeshDrawBlendParam( int MHandle , int MeshIndex , int BlendParam ) ;


		/// <summary> 指定のメッシュの描画ブレンドモードを取得する( DX_BLENDMODE_ALPHA 等 ) </summary>
		public static DX_BLENDMODE MV1GetMeshDrawBlendMode( Model MHandle , int MeshIndex )
		{
			lock( locker )
			{
				DX_BLENDMODE result = dx_MV1GetMeshDrawBlendMode( Model.ToHandle( MHandle ) , MeshIndex ) ;
				return result ;
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern DX_BLENDMODE dx_MV1GetMeshDrawBlendMode( int MHandle , int MeshIndex ) ;


		/// <summary> 指定のメッシュの描画ブレンドパラメータを設定する </summary>
		public static int MV1GetMeshDrawBlendParam( Model MHandle , int MeshIndex )
		{
			lock( locker )
			{
				int result = dx_MV1GetMeshDrawBlendParam( Model.ToHandle( MHandle ) , MeshIndex ) ;
				if( !( result >= 0 ) ) { throw new DX.Exception(); }
				return result ;
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1GetMeshDrawBlendParam( int MHandle , int MeshIndex ) ;


		/// <summary> 指定のメッシュの初期表示状態を設定する( TRUE:表示  FALSE:非表示 ) </summary>
		public static void MV1SetMeshBaseVisible( Model MHandle , int MeshIndex , bool VisibleFlag )
		{
			lock( locker )
			{
				int result = dx_MV1SetMeshBaseVisible( Model.ToHandle( MHandle ) , MeshIndex , VisibleFlag ) ;
				if( !( result == 0 ) ) { throw new DX.Exception(); }
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1SetMeshBaseVisible( int MHandle , int MeshIndex , bool VisibleFlag ) ;


		/// <summary> 指定のメッシュの初期表示状態を取得する( TRUE:表示  FALSE:非表示 ) </summary>
		public static bool MV1GetMeshBaseVisible( Model MHandle , int MeshIndex )
		{
			lock( locker )
			{
				int result = dx_MV1GetMeshBaseVisible( Model.ToHandle( MHandle ) , MeshIndex ) ;
				if( result == 0 ) { return false ; }
				else if( result == 1 ) { return true ; }
				else { throw new DX.Exception() ; }
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1GetMeshBaseVisible( int MHandle , int MeshIndex ) ;


		/// <summary> 指定のメッシュのバックカリングを行うかどうかを設定する( TRUE:する  FALSE:しない ) </summary>
		public static void MV1SetMeshBackCulling( Model MHandle , int MeshIndex , bool CullingFlag )
		{
			lock( locker )
			{
				int result = dx_MV1SetMeshBackCulling( Model.ToHandle( MHandle ) , MeshIndex , CullingFlag ) ;
				if( !( result == 0 ) ) { throw new DX.Exception(); }
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1SetMeshBackCulling( int MHandle , int MeshIndex , bool CullingFlag ) ;


		/// <summary> 指定のメッシュのバックカリングを行うかどうかを取得する( TRUE:する  FALSE:しない ) </summary>
		public static bool MV1GetMeshBackCulling( Model MHandle , int MeshIndex )
		{
			lock( locker )
			{
				int result = dx_MV1GetMeshBackCulling( Model.ToHandle( MHandle ) , MeshIndex ) ;
				if( result == 0 ) { return false ; }
				else if( result == 1 ) { return true ; }
				else { throw new DX.Exception() ; }
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1GetMeshBackCulling( int MHandle , int MeshIndex ) ;


		/// <summary> 指定のメッシュに含まれるポリゴンの最大ローカル座標を取得する </summary>
		public static VECTOR MV1GetMeshMaxPosition( Model MHandle , int MeshIndex )
		{
			lock( locker )
			{
				VECTOR result = dx_MV1GetMeshMaxPosition( Model.ToHandle( MHandle ) , MeshIndex ) ;
				return result ;
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern VECTOR dx_MV1GetMeshMaxPosition( int MHandle , int MeshIndex ) ;


		/// <summary> 指定のメッシュに含まれるポリゴンの最小ローカル座標を取得する </summary>
		public static VECTOR MV1GetMeshMinPosition( Model MHandle , int MeshIndex )
		{
			lock( locker )
			{
				VECTOR result = dx_MV1GetMeshMinPosition( Model.ToHandle( MHandle ) , MeshIndex ) ;
				return result ;
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern VECTOR dx_MV1GetMeshMinPosition( int MHandle , int MeshIndex ) ;


		/// <summary> 指定のメッシュに含まれるトライアングルリストの数を取得する </summary>
		public static int MV1GetMeshTListNum( Model MHandle , int MeshIndex )
		{
			lock( locker )
			{
				int result = dx_MV1GetMeshTListNum( Model.ToHandle( MHandle ) , MeshIndex ) ;
				if( !( result >= 0 ) ) { throw new DX.Exception(); }
				return result ;
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1GetMeshTListNum( int MHandle , int MeshIndex ) ;


		/// <summary> 指定のメッシュに含まれるトライアングルリストのインデックスを取得する </summary>
		public static int MV1GetMeshTList( Model MHandle , int MeshIndex , int Index )
		{
			lock( locker )
			{
				int result = dx_MV1GetMeshTList( Model.ToHandle( MHandle ) , MeshIndex , Index ) ;
				if( !( result >= 0 ) ) { throw new DX.Exception(); }
				return result ;
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1GetMeshTList( int MHandle , int MeshIndex , int Index ) ;


		/// <summary> 指定のメッシュに半透明要素があるかどうかを取得する( 戻り値 TRUE:ある  FALSE:ない ) </summary>
		public static bool MV1GetMeshSemiTransState( Model MHandle , int MeshIndex )
		{
			lock( locker )
			{
				int result = dx_MV1GetMeshSemiTransState( Model.ToHandle( MHandle ) , MeshIndex ) ;
				if( result == 0 ) { return false ; }
				else if( result == 1 ) { return true ; }
				else { throw new DX.Exception() ; }
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1GetMeshSemiTransState( int MHandle , int MeshIndex ) ;


		/// <summary> 指定のメッシュの頂点ディフューズカラーをマテリアルのディフューズカラーの代わりに使用するかどうかを設定する( TRUE:マテリアルカラーの代わりに使用する  FALSE:マテリアルカラーを使用する ) </summary>
		public static void MV1SetMeshUseVertDifColor( Model MHandle , int MeshIndex , bool UseFlag )
		{
			lock( locker )
			{
				int result = dx_MV1SetMeshUseVertDifColor( Model.ToHandle( MHandle ) , MeshIndex , UseFlag ) ;
				if( !( result == 0 ) ) { throw new DX.Exception(); }
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1SetMeshUseVertDifColor( int MHandle , int MeshIndex , bool UseFlag ) ;


		/// <summary> 指定のメッシュの頂点スペキュラカラーをマテリアルのスペキュラカラーの代わりに使用するかどうかを設定する( TRUE:マテリアルカラーの代わりに使用する  FALSE:マテリアルカラーを使用する ) </summary>
		public static void MV1SetMeshUseVertSpcColor( Model MHandle , int MeshIndex , bool UseFlag )
		{
			lock( locker )
			{
				int result = dx_MV1SetMeshUseVertSpcColor( Model.ToHandle( MHandle ) , MeshIndex , UseFlag ) ;
				if( !( result == 0 ) ) { throw new DX.Exception(); }
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1SetMeshUseVertSpcColor( int MHandle , int MeshIndex , bool UseFlag ) ;


		/// <summary> 指定のメッシュの頂点ディフューズカラーをマテリアルのディフューズカラーの代わりに使用するかどうかの設定を取得する( 戻り値  TRUE:マテリアルカラーの代わりに使用する  FALSE:マテリアルカラーを使用する ) </summary>
		public static bool MV1GetMeshUseVertDifColor( Model MHandle , int MeshIndex )
		{
			lock( locker )
			{
				int result = dx_MV1GetMeshUseVertDifColor( Model.ToHandle( MHandle ) , MeshIndex ) ;
				if( result == 0 ) { return false ; }
				else if( result == 1 ) { return true ; }
				else { throw new DX.Exception() ; }
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1GetMeshUseVertDifColor( int MHandle , int MeshIndex ) ;


		/// <summary> 指定のメッシュの頂点スペキュラカラーをマテリアルのスペキュラカラーの代わりに使用するかどうかの設定を取得する( 戻り値  TRUE:マテリアルカラーの代わりに使用する  FALSE:マテリアルカラーを使用する ) </summary>
		public static bool MV1GetMeshUseVertSpcColor( Model MHandle , int MeshIndex )
		{
			lock( locker )
			{
				int result = dx_MV1GetMeshUseVertSpcColor( Model.ToHandle( MHandle ) , MeshIndex ) ;
				if( result == 0 ) { return false ; }
				else if( result == 1 ) { return true ; }
				else { throw new DX.Exception() ; }
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1GetMeshUseVertSpcColor( int MHandle , int MeshIndex ) ;


		/// <summary> トライアングルリストの数を取得する </summary>
		public static int MV1GetTriangleListNum( Model MHandle )
		{
			lock( locker )
			{
				int result = dx_MV1GetTriangleListNum( Model.ToHandle( MHandle ) ) ;
				if( !( result >= 0 ) ) { throw new DX.Exception(); }
				return result ;
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1GetTriangleListNum( int MHandle ) ;


		/// <summary> 指定のトライアングルリストの頂点データタイプを取得する( MV1_VERTEX_TYPE_NORMAL 等 ) </summary>
		public static MV1_VERTEX_TYPE MV1GetTriangleListVertexType( Model MHandle , int TListIndex )
		{
			lock( locker )
			{
				MV1_VERTEX_TYPE result = dx_MV1GetTriangleListVertexType( Model.ToHandle( MHandle ) , TListIndex ) ;
				return result ;
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern MV1_VERTEX_TYPE dx_MV1GetTriangleListVertexType( int MHandle , int TListIndex ) ;


		/// <summary> 指定のトライアングルリストに含まれるポリゴンの数を取得する </summary>
		public static int MV1GetTriangleListPolygonNum( Model MHandle , int TListIndex )
		{
			lock( locker )
			{
				int result = dx_MV1GetTriangleListPolygonNum( Model.ToHandle( MHandle ) , TListIndex ) ;
				if( !( result >= 0 ) ) { throw new DX.Exception(); }
				return result ;
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1GetTriangleListPolygonNum( int MHandle , int TListIndex ) ;


		/// <summary> 指定のトライアングルリストに含まれる頂点データの数を取得する </summary>
		public static int MV1GetTriangleListVertexNum( Model MHandle , int TListIndex )
		{
			lock( locker )
			{
				int result = dx_MV1GetTriangleListVertexNum( Model.ToHandle( MHandle ) , TListIndex ) ;
				if( !( result >= 0 ) ) { throw new DX.Exception(); }
				return result ;
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1GetTriangleListVertexNum( int MHandle , int TListIndex ) ;


		/// <summary> コリジョン情報を構築する </summary>
		public static void MV1SetupCollInfo( Model MHandle )
		{
			MV1SetupCollInfo( MHandle , -1 ) ;
		}

		/// <summary> コリジョン情報を構築する </summary>
		public static void MV1SetupCollInfo( Model MHandle , int FrameIndex )
		{
			MV1SetupCollInfo( MHandle , FrameIndex , 32 ) ;
		}

		/// <summary> コリジョン情報を構築する </summary>
		public static void MV1SetupCollInfo( Model MHandle , int FrameIndex , int XDivNum )
		{
			MV1SetupCollInfo( MHandle , FrameIndex , XDivNum , 8 ) ;
		}

		/// <summary> コリジョン情報を構築する </summary>
		public static void MV1SetupCollInfo( Model MHandle , int FrameIndex , int XDivNum , int YDivNum )
		{
			MV1SetupCollInfo( MHandle , FrameIndex , XDivNum , YDivNum , 32 ) ;
		}

		/// <summary> コリジョン情報を構築する </summary>
		public static void MV1SetupCollInfo( Model MHandle , int FrameIndex , int XDivNum , int YDivNum , int ZDivNum )
		{
			lock( locker )
			{
				int result = dx_MV1SetupCollInfo( Model.ToHandle( MHandle ) , FrameIndex , XDivNum , YDivNum , ZDivNum ) ;
				if( !( result == 0 ) ) { throw new DX.Exception(); }
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1SetupCollInfo( int MHandle , int FrameIndex , int XDivNum , int YDivNum , int ZDivNum ) ;


		/// <summary> コリジョン情報の後始末 </summary>
		public static void MV1TerminateCollInfo( Model MHandle )
		{
			MV1TerminateCollInfo( MHandle , -1 ) ;
		}

		/// <summary> コリジョン情報の後始末 </summary>
		public static void MV1TerminateCollInfo( Model MHandle , int FrameIndex )
		{
			lock( locker )
			{
				int result = dx_MV1TerminateCollInfo( Model.ToHandle( MHandle ) , FrameIndex ) ;
				if( !( result == 0 ) ) { throw new DX.Exception(); }
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1TerminateCollInfo( int MHandle , int FrameIndex ) ;


		/// <summary> コリジョン情報を更新する </summary>
		public static void MV1RefreshCollInfo( Model MHandle )
		{
			MV1RefreshCollInfo( MHandle , -1 ) ;
		}

		/// <summary> コリジョン情報を更新する </summary>
		public static void MV1RefreshCollInfo( Model MHandle , int FrameIndex )
		{
			lock( locker )
			{
				int result = dx_MV1RefreshCollInfo( Model.ToHandle( MHandle ) , FrameIndex ) ;
				if( !( result == 0 ) ) { throw new DX.Exception(); }
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1RefreshCollInfo( int MHandle , int FrameIndex ) ;


		/// <summary> 線とモデルの当たり判定 </summary>
		public static MV1_COLL_RESULT_POLY MV1CollCheck_Line( Model MHandle , int FrameIndex , VECTOR PosStart , VECTOR PosEnd )
		{
			lock( locker )
			{
				MV1_COLL_RESULT_POLY result = dx_MV1CollCheck_Line( Model.ToHandle( MHandle ) , FrameIndex , PosStart , PosEnd ) ;
				return result ;
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern MV1_COLL_RESULT_POLY dx_MV1CollCheck_Line( int MHandle , int FrameIndex , VECTOR PosStart , VECTOR PosEnd ) ;


		/// <summary> 線とモデルの当たり判定( 戻り値が MV1_COLL_RESULT_POLY_DIM ) </summary>
		public static MV1_COLL_RESULT_POLY[] MV1CollCheck_LineDim( Model MHandle , int FrameIndex , VECTOR PosStart , VECTOR PosEnd )
		{
			lock( locker )
			{
				MV1_COLL_RESULT_POLY_DIM source = dx_MV1CollCheck_LineDim( Model.ToHandle( MHandle ) , FrameIndex , PosStart , PosEnd ) ;

				try
				{
					MV1_COLL_RESULT_POLY[] target = new MV1_COLL_RESULT_POLY[ source.HitNum ] ;

					for( int i = 0 ; i < target.Length ; i ++ )
					{
						unsafe
						{
							target[ i ] = source.Dim[ i ] ;
						}
					}

					return target ;
				}
				finally
				{
					dx_MV1CollResultPolyDimTerminate( source ) ;
				}
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern MV1_COLL_RESULT_POLY_DIM dx_MV1CollCheck_LineDim( int MHandle , int FrameIndex , VECTOR PosStart , VECTOR PosEnd ) ;


		/// <summary> 球とモデルの当たり判定 </summary>
		public static MV1_COLL_RESULT_POLY[] MV1CollCheck_Sphere( Model MHandle , int FrameIndex , VECTOR CenterPos , float r )
		{
			lock( locker )
			{
				MV1_COLL_RESULT_POLY_DIM source = dx_MV1CollCheck_Sphere( Model.ToHandle( MHandle ) , FrameIndex , CenterPos , r ) ;

				try
				{
					MV1_COLL_RESULT_POLY[] target = new MV1_COLL_RESULT_POLY[ source.HitNum ] ;

					for( int i = 0 ; i < target.Length ; i ++ )
					{
						unsafe
						{
							target[ i ] = source.Dim[ i ] ;
						}
					}

					return target ;
				}
				finally
				{
					dx_MV1CollResultPolyDimTerminate( source ) ;
				}
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern MV1_COLL_RESULT_POLY_DIM dx_MV1CollCheck_Sphere( int MHandle , int FrameIndex , VECTOR CenterPos , float r ) ;


		/// <summary> カプセルとモデルの当たり判定 </summary>
		public static MV1_COLL_RESULT_POLY[] MV1CollCheck_Capsule( Model MHandle , int FrameIndex , VECTOR Pos1 , VECTOR Pos2 , float r )
		{
			lock( locker )
			{
				MV1_COLL_RESULT_POLY_DIM source = dx_MV1CollCheck_Capsule( Model.ToHandle( MHandle ) , FrameIndex , Pos1 , Pos2 , r ) ;

				try
				{
					MV1_COLL_RESULT_POLY[] target = new MV1_COLL_RESULT_POLY[ source.HitNum ] ;

					for( int i = 0 ; i < target.Length ; i ++ )
					{
						unsafe
						{
							target[ i ] = source.Dim[ i ] ;
						}
					}

					return target ;
				}
				finally
				{
					dx_MV1CollResultPolyDimTerminate( source ) ;
				}
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern MV1_COLL_RESULT_POLY_DIM dx_MV1CollCheck_Capsule( int MHandle , int FrameIndex , VECTOR Pos1 , VECTOR Pos2 , float r ) ;


	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern MV1_COLL_RESULT_POLY dx_MV1CollCheck_GetResultPoly( MV1_COLL_RESULT_POLY_DIM ResultPolyDim , int PolyNo ) ;

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1CollResultPolyDimTerminate( MV1_COLL_RESULT_POLY_DIM ResultPolyDim ) ;

	#if UNICODE
		[ StructLayout( LayoutKind.Sequential , CharSet = CharSet.Unicode ) ]
	#else
		[ StructLayout( LayoutKind.Sequential , CharSet = CharSet.Ansi ) ]
	#endif
		private unsafe struct MV1_COLL_RESULT_POLY_DIM
		{

			public int HitNum ;

			public MV1_COLL_RESULT_POLY *Dim ;
		}


		/// <summary> 参照用メッシュを取得する </summary>
		public static MV1_REF_POLYGONLIST MV1GetReferenceMesh( Model MHandle , int FrameIndex , bool IsTransform )
		{
			lock( locker )
			{
				int result = dx_MV1SetupReferenceMesh( Model.ToHandle( MHandle ) , FrameIndex , IsTransform ) ;
				if( !( result == 0 ) ) { throw new DX.Exception(); }

				try
				{
					MV1_REF_POLYGONLIST_ source = dx_MV1GetReferenceMesh( Model.ToHandle( MHandle ) , FrameIndex , IsTransform ) ;
					MV1_REF_POLYGONLIST target = new MV1_REF_POLYGONLIST() ;
					target.MinPosition = source.MinPosition ;
					target.MaxPosition = source.MaxPosition ;
					target.Polygons = new MV1_REF_POLYGON[ source.PolygonNum ] ;
					target.Vertexs = new MV1_REF_VERTEX[ source.VertexNum ] ;

					for( int i = 0 ; i < target.Polygons.Length ; i ++ )
					{
						unsafe
						{
							target.Polygons[ i ] = source.Polygons[ i ] ;
						}
					}

					for( int i = 0 ; i < target.Vertexs.Length ; i ++ )
					{
						unsafe
						{
							target.Vertexs[ i ] = source.Vertexs[ i ] ;
						}
					}

					return target ;
				}
				finally
				{
					dx_MV1TerminateReferenceMesh( Model.ToHandle( MHandle ) , FrameIndex , IsTransform ) ;
				}
			}
		}

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1SetupReferenceMesh( int MHandle , int FrameIndex , bool IsTransform ) ;

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1TerminateReferenceMesh( int MHandle , int FrameIndex , bool IsTransform ) ;

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern int dx_MV1RefreshReferenceMesh( int MHandle , int FrameIndex , bool IsTransform ) ;

	#if UNICODE
		[ DllImport( "DxLibW.dll" , CharSet = CharSet.Unicode , ExactSpelling = true ) ]
	#else
		[ DllImport( "DxLib.dll" , CharSet = CharSet.Ansi , ExactSpelling = true ) ]
	#endif
		private static extern MV1_REF_POLYGONLIST_ dx_MV1GetReferenceMesh( int MHandle , int FrameIndex , bool IsTransform ) ;

	#if UNICODE
		[ StructLayout( LayoutKind.Sequential , CharSet = CharSet.Unicode ) ]
	#else
		[ StructLayout( LayoutKind.Sequential , CharSet = CharSet.Ansi ) ]
	#endif
		private unsafe struct MV1_REF_POLYGONLIST_
		{

			public int PolygonNum ;

			public int VertexNum ;

			public VECTOR MinPosition ;

			public VECTOR MaxPosition ;

			public MV1_REF_POLYGON *Polygons ;

			public MV1_REF_VERTEX *Vertexs ;
		}
	}
}
