//------------------------------------------------------------------------------
// Lamp : Open source game middleware
// Copyright (C) 2004  Junpei Ohtani ( Email : junpee@users.sourceforge.jp )
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
//------------------------------------------------------------------------------

/** @file
 * グラフィックスデバイス能力ヘッダ
 * @author Junpee
 */

#ifndef GRAPHICS_DEVICE_CAPACITY_H_
#define GRAPHICS_DEVICE_CAPACITY_H_

#include <Graphics/Primitive/VertexProcessingType.h>

namespace Lamp{

//------------------------------------------------------------------------------
/**
 * グラフィックスデバイス能力
 */
class GraphicsDeviceCapacity{
friend class LampGraphics;
public:
	//--------------------------------------------------------------------------
	/**
	 * インスタンス取得
	 * @return インスタンス
	 */
	static GraphicsDeviceCapacity* getInstance(){
		Assert(instance_ != NULL);
		return instance_;
	}

	//--------------------------------------------------------------------------
	/**
	 * デバイス能力の取得
	 * @return デバイス能力
	 */
	virtual const D3DCapacity& getCapacity() const{ return capacity_; }

	/**
	 * 文字列への変換
	 * @return グラフィックスデバイス能力文字列
	 */
	virtual String toString() const;

	//--------------------------------------------------------------------------
	// デバイス情報
	//--------------------------------------------------------------------------
	/**
	 * デバイス名の取得
	 * @return デバイス名
	 */
	virtual const String& getDeviceName() const{ return deviceName_; }

	/**
	 * ドライバ名の取得
	 * @return ドライバ名
	 */
	virtual const String& getDriverName() const{ return driverName_; }

	/**
	 * デバイス番号の取得
	 * @return デバイス番号
	 */
	virtual int getDeviceOrdinal() const{ return deviceOrdinal_; }

	/**
	 * デバイスタイプの取得
	 * @return デバイスタイプ
	 */
	virtual D3DDEVTYPE getDeviceType() const{ return deviceType_; }

	/**
	 * ウィンドウモードの取得
	 * @return ウィンドウモードならtrue
	 */
	virtual bool isWindowed() const{ return isWindowed_; }

	/**
	 * 頂点プロセスタイプの取得
	 * @return 頂点プロセスタイプ
	 */
	virtual VertexProcessingType getVertexProcessingType() const{
		return vertexProcessingType_;
	}

	/**
	 * アダプタフォーマットの取得
	 * @return アダプタフォーマット
	 */
	virtual D3DFORMAT getAdapterFormat() const{ return adapterFormat_; }

	/**
	 * バックバッファフォーマットの取得
	 * @return バックバッファフォーマット
	 */
	virtual D3DFORMAT getBackBufferFormat() const{ return backBufferFormat_; }

	/**
	 * バックバッファサイズの取得
	 * @return バックバッファサイズ
	 */
	virtual const DimensionI& getBackBufferSize() const{
		return backBufferSize_;
	}

	/**
	 * バックバッファアスペクト比の取得
	 * @return バックバッファアスペクト比
	 */
	virtual float getBackBufferAspectRate() const{
		return ((float)backBufferSize_.width / (float)backBufferSize_.height);
	}

	/**
	 * リフレッシュレートの取得
	 * @return リフレッシュレート
	 */
	virtual int getRefreshRate() const{ return refreshRate_; }

	/**
	 * 深度、ステンシルバッファは有効か
	 * @return 深度、ステンシルバッファが有効ならtrue
	 */
	virtual bool getDepthStencilEnabled() const{ return depthStencilEnabled_; }

	/**
	 * 深度、ステンシルフォーマットの取得
	 * @return 深度、ステンシルフォーマット
	 */
	virtual D3DFORMAT getDepthStencilFormat() const{
		return depthStencilFormat_;
	}

	/**
	 * プレゼンテーション間隔の取得
	 * @return プレゼンテーション間隔
	 */
	virtual int getPresentationInterval() const{ return presentationInterval_; }

	/**
	 * マルチサンプルタイプの取得
	 * @return マルチサンプルタイプ
	 */
	virtual D3DMULTISAMPLE_TYPE getMultiSampleType() const{
		return multiSampleType_;
	}

	/**
	 * マルチサンプルクォリティの取得
	 * @return マルチサンプルクォリティ
	 */
	virtual u_int getMultiSampleQuality() const{ return multiSampleQuality_; }

	//--------------------------------------------------------------------------
	// デバイス能力
	//--------------------------------------------------------------------------
	/**
	 * マルチレンダーターゲット数の取得
	 * @return マルチレンダーターゲット数
	 */
	virtual u_int getNumSimultaneousRTs() const{ return numSimultaneousRTs_; }

	/**
	 * システムメモリで実行はサポートされているか
	 * @return システムメモリで実行がサポートされているならtrue
	 */
	virtual bool supportedExecuteSystemMemory() const{
		return executeSystemMemory_;
	}

	/**
	 * ビデオメモリで実行はサポートされているか
	 * @return ビデオメモリで実行がサポートされているならtrue
	 */
	virtual bool supportedExecuteVideoMemory() const{
		return executeVideoMemory_;
	}

	/**
	 * システムメモリ上のTL頂点はサポートされているか
	 * @return システムメモリ上のTL頂点がサポートされているならtrue
	 */
	virtual bool supportedTlVertexSystemMemory() const{
		return tlVertexSystemMemory_;
	}

	/**
	 * ビデオメモリ上のTL頂点はサポートされているか
	 * @return ビデオメモリ上のTL頂点がサポートされているならtrue
	 */
	virtual bool supportedTlVertexVideoMemory() const{
		return tlVertexVideoMemory_;
	}

	/**
	 * システムメモリ上のテクスチャはサポートされているか
	 * @return システムメモリ上のテクスチャがサポートされているならtrue
	 */
	virtual bool supportedTextureSystemMemory() const{
		return textureSystemMemory_;
	}

	/**
	 * ビデオメモリ上のテクスチャはサポートされているか
	 * @return ビデオメモリ上のテクスチャがサポートされているならtrue
	 */
	virtual bool supportedTextureVideoMemory() const{
		return textureVideoMemory_;
	}

	/**
	 * TL頂点の描画はサポートされているか
	 * @return TL頂点の描画がサポートされているならtrue
	 */
	virtual bool supportedDrawPrimTlVertex() const{
		return drawPrimTlVertex_;
	}

	/**
	 * フリップ後のレンダリングはサポートされているか
	 * @return フリップ後のレンダリングがサポートされているならtrue
	 */
	virtual bool supportedCanRenderAfterFlip() const{
		return canRenderAfterFlip_;
	}

	/**
	 * 非ローカルビデオメモリはサポートされているか
	 * @return 非ローカルビデオメモリがサポートされているならtrue
	 */
	virtual bool supportedTextureNonLocalVidedMemory() const{
		return textureNonLocalVidedMemory_;
	}

	/**
	 * DrawPrivitives2はサポートされているか
	 * @return DrawPrivitives2がサポートされているならtrue
	 */
	virtual bool supportedDrawPrimitives2() const{ return drawPrimitives2_; }

	/**
	 * 独立したテクスチャメモリプールはサポートされているか
	 * @return 独立したテクスチャメモリプールがサポートされているならtrue
	 */
	virtual bool supportedSeparateTextureMemories() const{
		return separateTextureMemories_;
	}

	/**
	 * DrawPrimitives2EXはサポートされているか
	 * @return DrawPrimitives2EXがサポートされているならtrue
	 */
	virtual bool supportedDrawPrimitives2EX() const{
		return drawPrimitives2EX_;
	}

	/**
	 * ハードウェアT&Lはサポートされているか
	 * @return ハードウェアT&Lがサポートされているならtrue
	 */
	virtual bool supportedHwTransformAndLight() const{
		return hwTransformAndLight_;
	}

	/**
	 * システムからビデオへのBLTはサポートされているか
	 * @return システムからビデオへのBLTがサポートされているならtrue
	 */
	virtual bool supportedCanBltSystemToNonLocal() const{
		return canBltSystemToNonLocal_;
	}

	/**
	 * ハードウェアラスタライズはサポートされているか
	 * @return ハードウェアラスタライズがサポートされているならtrue
	 */
	virtual bool supportedHwRasterization() const{ return hwRasterization_; }

	/**
	 * ピュアデバイスはサポートされているか
	 * @return ピュアデバイスがサポートされているならtrue
	 */
	virtual bool supportedPureDevice() const{ return pureDevice_; }

	/**
	 * ベジェ、Bスプラインはサポートされているか
	 * @return ベジェ、Bスプラインがサポートされているならtrue
	 */
	virtual bool supportedQuinticRtPatches() const{ return quinticRtPatches_; }

	/**
	 * 矩形、三角形パッチはサポートされているか
	 * @return 矩形、三角形パッチがサポートされているならtrue
	 */
	virtual bool supportedRtPatches() const{ return rtPatches_; }

	/**
	 * 効率的なハンドル0パッチはサポートされているか
	 * @return 効率的なハンドル0パッチがサポートされているならtrue
	 */
	virtual bool supportedRtPatchHanldeZero() const{
		return rtPatchHanldeZero_;
	}

	/**
	 * Nパッチはサポートされているか
	 * @return Nパッチがサポートされているならtrue
	 */
	virtual bool supportedNPatches() const{ return nPatches_; }

	/**
	 * プレゼンテーション間隔即時はサポートされているか
	 * @return プレゼンテーション間隔即時がサポートされているならtrue
	 */
	virtual bool supportedPresentationIntervalImmediate() const{
		return presentationIntervalImmediate_;
	}

	/**
	 * プレゼンテーション間隔1垂直同期はサポートされているか
	 * @return プレゼンテーション間隔1垂直同期がサポートされているならtrue
	 */
	virtual bool supportedPresentationIntervalOne() const{
		return presentationIntervalOne_;
	}

	/**
	 * プレゼンテーション間隔2垂直同期はサポートされているか
	 * @return プレゼンテーション間隔2垂直同期がサポートされているならtrue
	 */
	virtual bool supportedPresentationIntervalTwo() const{
		return presentationIntervalTwo_;
	}

	/**
	 * プレゼンテーション間隔3垂直同期はサポートされているか
	 * @return プレゼンテーション間隔3垂直同期がサポートされているならtrue
	 */
	virtual bool supportedPresentationIntervalThree() const{
		return presentationIntervalThree_;
	}

	/**
	 * プレゼンテーション間隔4垂直同期はサポートされているか
	 * @return プレゼンテーション間隔4垂直同期がサポートされているならtrue
	 */
	virtual bool supportedPresentationIntervalFour() const{
		return presentationIntervalFour_;
	}

	/**
	 * ハードウェアカーソルはサポートされているか
	 * @return ハードウェアカーソルがサポートされているならtrue
	 */
	virtual bool supportedCursorColor() const{ return cursorColor_; }

	/**
	 * 低解像度ハードウェアカーソルはサポートされているか
	 * @return 低解像度ハードウェアカーソルがサポートされているならtrue
	 */
	virtual bool supportedCursorLowRes() const{ return cursorLowRes_; }

	/**
	 * StretchRectMinPointフィルタはサポートされているか
	 * @return StretchRectMinPointフィルタがサポートされているならtrue
	 */
	virtual bool supportedStretchRectMinPoint() const{
		return stretchRectMinPoint_;
	}

	/**
	 * StretchRectMagPointフィルタはサポートされているか
	 * @return StretchRectMagPointフィルタがサポートされているならtrue
	 */
	virtual bool supportedStretchRectMagPoint() const{
		return stretchRectMagPoint_;
	}

	/**
	 * StretchRectMinLinearフィルタはサポートされているか
	 * @return StretchRectMinLinearフィルタがサポートされているならtrue
	 */
	virtual bool supportedStretchRectMinLinear() const{
		return stretchRectMinLinear_;
	}

	/**
	 * StretchRectMagLinearフィルタはサポートされているか
	 * @return StretchRectMagLinearフィルタがサポートされているならtrue
	 */
	virtual bool supportedStretchRectMagLinear() const{
		return stretchRectMagLinear_;
	}

	//--------------------------------------------------------------------------
	// デバイスその他
	//--------------------------------------------------------------------------
	/**
	 * マスターアダプタ番号の取得
	 * @return マスターアダプタ番号
	 */
	virtual u_int getMasterAdapterOrdinal() const{
		return masterAdapterOrdinal_;
	}

	/**
	 * グループ内のアダプタ番号の取得
	 * @return グループ内のアダプタ番号
	 */
	virtual u_int getAdapterOrdinalInGroup() const{
		return adapterOrdinalInGroup_;
	}

	/**
	 * グループのアダプタ数の取得
	 * @return グループのアダプタ数
	 */
	virtual u_int getNumberOfAdaptersInGroup() const{
		return numberOfAdaptersInGroup_;
	}

	/**
	 * Zマスクはサポートされているか
	 * @return Zマスクがサポートされているならtrue
	 */
	virtual bool supportedMaskZ() const{ return maskZ_; }

	/**
	 * カリング無しはサポートされているか
	 * @return カリング無しがサポートされているならtrue
	 */
	virtual bool supportedCullNone() const{ return cullNone_; }

	/**
	 * 時計回りカリングはサポートされているか
	 * @return 時計回りカリングがサポートされているならtrue
	 */
	virtual bool supportedCullCW() const{ return cullCW_; }

	/**
	 * 反時計回りカリングはサポートされているか
	 * @return 反時計回りカリングがサポートされているならtrue
	 */
	virtual bool supportedCullCCW() const{ return cullCCW_; }

	/**
	 * カラーチャンネル書き込みはサポートされているか
	 * @return カラーチャンネル書き込みがサポートされているならtrue
	 */
	virtual bool supportedColorWriteEnable() const{ return colorWriteEnable_; }

	/**
	 * 正確なポイントクリップはサポートされているか
	 * @return 正確なポイントクリップがサポートされているならtrue
	 */
	virtual bool supportedClipPlaneScaledPoints() const{
		return clipPlaneScaledPoints_;
	}

	/**
	 * 頂点クリップはサポートされているか
	 * @return 頂点クリップがサポートされているならtrue
	 */
	virtual bool supportedClipTlVerts() const{ return clipTlVerts_; }

	/**
	 * テンポラリテクスチャ引数はサポートされているか
	 * @return テンポラリテクスチャ引数がサポートされているならtrue
	 */
	virtual bool supportedTssArgTemp() const{ return tssArgTemp_; }

	/**
	 * アルファブレンディングはサポートされているか
	 * @return アルファブレンディングがサポートされているならtrue
	 */
	virtual bool supportedBlendOp() const{ return blendOp_; }

	/**
	 * ヌルリファレンスはサポートされているか
	 * @return ヌルリファレンスがサポートされているならtrue
	 */
	virtual bool supportedNullReference() const{ return nullReference_; }

	/**
	 * 独立した書き込みマスクはサポートされているか
	 * @return 独立した書き込みマスクがサポートされているならtrue
	 */
	virtual bool supportedIndependentWriteMasks() const{
		return independentWriteMasks_;
	}

	/**
	 * テクスチャステージ定数はサポートされているか
	 * @return テクスチャステージ定数がサポートされているならtrue
	 */
	virtual bool supportedPerStageConstant() const{ return perStageConstant_; }

	/**
	 * フォグとスペキュラアルファはサポートされているか
	 * @return フォグとスペキュラアルファがサポートされているならtrue
	 */
	virtual bool supportedFogAndSpecularAlpha() const{
		return fogAndSpecularAlpha_;
	}

	/**
	 * アルファ用ブレンドはサポートされているか
	 * @return アルファ用ブレンドがサポートされているならtrue
	 */
	virtual bool supportedSeparateAlphaBlend() const{
		return separateAlphaBlend_;
	}

	/**
	 * MRTに違うZ深度はサポートされているか
	 * @return MRTに違うZ深度がサポートされているならtrue
	 */
	virtual bool supportedMrtIndependentBitDepth() const{
		return mrtIndependentBitDepth_;
	}

	/**
	 * MRTにピクセルシェーダ後処理はサポートされているか
	 * @return MRTにピクセルシェーダ後処理がサポートされているならtrue
	 */
	virtual bool supportedMrtPostPixelShaderBlending() const{
		return mrtPostPixelShaderBlending_;
	}

	/**
	 * 頂点フォグのクランプはサポートされているか
	 * @return 頂点フォグのクランプがサポートされているならtrue
	 */
	virtual bool supportedFogVertexClamped() const{ return fogVertexClamped_; }

	//--------------------------------------------------------------------------
	// ドライバ能力
	//--------------------------------------------------------------------------
	/**
	 * スキャンラインの読み込みはサポートされているか
	 * @return スキャンラインの読み込みがサポートされているならtrue
	 */
	virtual bool supportedReadScanLine() const{ return readScanLine_; }

	/**
	 * フルスクリーンガンマはサポートされているか
	 * @return フルスクリーンガンマがサポートされているならtrue
	 */
	virtual bool supportedFullscreenGamma() const{ return fullscreenGamma_; }

	/**
	 * キャリブレートガンマはサポートされているか
	 * @return キャリブレートガンマがサポートされているならtrue
	 */
	virtual bool supportedCanCalibrateGamma() const{
		return canCalibrateGamma_;
	}

	/**
	 * マネージドリソースはサポートされているか
	 * @return マネージドリソースがサポートされているならtrue
	 */
	virtual bool supportedCanManageResource() const{
		return canManageResource_;
	}

	/**
	 * 動的テクスチャはサポートされているか
	 * @return 動的テクスチャがサポートされているならtrue
	 */
	virtual bool supportedDynamicTextures() const{ return dynamicTextures_; }

	/**
	 * ミップマップ自動生成はサポートされているか
	 * @return ミップマップ自動生成がサポートされているならtrue
	 */
	virtual bool supportedCanAutogenMipmap() const{ return canAutogenMipmap_; }

	/**
	 * フルスクリーンアルファブレンドはサポートされているか
	 * @return フルスクリーンアルファブレンドがサポートされているならtrue
	 */
	virtual bool supportedAlphaFullscreenFlipOrDiscard() const{
		return alphaFullscreenFlipOrDiscard_;
	}

	/**
	 * sRGBプレゼンテーションはサポートされているか
	 * @return sRGBプレゼンテーションがサポートされているならtrue
	 */
	virtual bool supportedLinerToSrgbPresentation() const{
		return linerToSrgbPresentation_;
	}

	/**
	 * ビデオメモリへのコピーはサポートされているか
	 * @return ビデオメモリへのコピーがサポートされているならtrue
	 */
	virtual bool supportedCopyToVideoMemory() const{
		return copyToVideoMemory_;
	}

	/**
	 * システムメモリへのコピーはサポートされているか
	 * @return システムメモリへのコピーがサポートされているならtrue
	 */
	virtual bool supportedCopyToSystemMemory() const{
		return copyToSystemMemory_;
	}

	//--------------------------------------------------------------------------
	// プリミティブ
	//--------------------------------------------------------------------------
	/**
	 * 最大点サイズの取得
	 * @return 最大点サイズ
	 */
	virtual float getMaxPointSize() const{ return maxPointSize_; }

	/**
	 * ラインテクスチャはサポートされているか
	 * @return ラインテクスチャがサポートされているならtrue
	 */
	virtual bool supportedLineTexture() const{ return lineTexture_; }

	/**
	 * ラインZテストはサポートされているか
	 * @return ラインZテストがサポートされているならtrue
	 */
	virtual bool supportedLineZTest() const{ return lineZTest_; }

	/**
	 * ラインブレンドはサポートされているか
	 * @return ラインブレンドがサポートされているならtrue
	 */
	virtual bool supportedLineBlend() const{ return lineBlend_; }

	/**
	 * ラインフォグはサポートされているか
	 * @return ラインフォグがサポートされているならtrue
	 */
	virtual bool supportedLineFog() const{ return lineFog_; }

	/**
	 * ラインアルファ比較はサポートされているか
	 * @return ラインアルファ比較がサポートされているならtrue
	 */
	virtual bool supportedLineAlphaCompare() const{ return lineAlphaCompare_; }

	/**
	 * ラインアンチエイリアスはサポートされているか
	 * @return ラインアンチエイリアスがサポートされているならtrue
	 */
	virtual bool supportedLineAntialias() const{ return lineAntialias_; }

	//--------------------------------------------------------------------------
	// 頂点処理
	//--------------------------------------------------------------------------
	/**
	 * 最大プリミティブ数の取得
	 * @return 最大プリミティブ数
	 */
	virtual u_int getMaxPrimitiveCount() const{ return maxPrimitiveCount_; }

	/**
	 * 最大インデックス数の取得
	 * @return 最大インデックス数
	 */
	virtual u_int getMaxVertexIndex() const{ return maxVertexIndex_; }

	/**
	 * 最大ストリーム数の取得
	 * @return 最大ストリーム数
	 */
	virtual u_int getMaxStreams() const{ return maxStreams_; }

	/**
	 * 最大ライト数の取得
	 * @return 最大ライト数
	 */
	virtual u_int getMaxActiveLights() const{ return maxActiveLights_; }

	/**
	 * 最大W値の取得
	 * @return 最大W値
	 */
	virtual float getMaxVertexW() const{ return maxVertexW_; }

	/**
	 * 最大ブレンド行列数の取得
	 * @return 最大ブレンド行列数
	 */
	virtual u_int getMaxVertexBlendMatrices() const{
		return maxVertexBlendMatrices_;
	}

	/**
	 * 最大ブレンド行列インデックス数の取得
	 * @return 最大ブレンド行列インデックス数
	 */
	virtual u_int getMaxVertexBlendMatrixIndex() const{
		return maxVertexBlendMatrixIndex_;
	}

	/**
	 * ガードバンド左の取得
	 * @return ガードバンド左
	 */
	virtual float getGuardBandLeft() const{ return guardBandLeft_; }

	/**
	 * ガードバンド上の取得
	 * @return ガードバンド上
	 */
	virtual float getGuardBandTop() const{ return guardBandTop_; }

	/**
	 * ガードバンド右の取得
	 * @return ガードバンド右
	 */
	virtual float getGuardBandRight() const{ return guardBandRight_; }

	/**
	 * ガードバンド下の取得
	 * @return ガードバンド下
	 */
	virtual float getGuardBandBottom() const{ return guardBandBottom_; }

	/**
	 * 最大ユーザクリップ面の取得
	 * @return 最大ユーザクリップ面
	 */
	virtual u_int getMaxUserCliplanes() const{ return maxUserCliplanes_; }

	/**
	 * Texgenはサポートされているか
	 * @return Texgenがサポートされているならtrue
	 */
	virtual bool supportedTexGen() const{ return texGen_; }

	/**
	 * カラーマテリアルソースはサポートされているか
	 * @return カラーマテリアルソースがサポートされているならtrue
	 */
	virtual bool supportedMaterialSource() const{ return materialSource_; }

	/**
	 * ディレクショナルライトはサポートされているか
	 * @return ディレクショナルライトがサポートされているならtrue
	 */
	virtual bool supportedDirectionalLights() const{
		return directionalLights_;
	}

	/**
	 * ポジションライトはサポートされているか
	 * @return ポジションライトがサポートされているならtrue
	 */
	virtual bool supportedPositionalLights() const{ return positionalLights_; }

	/**
	 * ローカルビューワはサポートされているか
	 * @return ローカルビューワがサポートされているならtrue
	 */
	virtual bool supportedLocalViewer() const{ return localViewer_; }

	/**
	 * 頂点トゥイーニングはサポートされているか
	 * @return 頂点トゥイーニングがサポートされているならtrue
	 */
	virtual bool supportedTweening() const{ return tweening_; }

	/**
	 * スフィアマップはサポートされているか
	 * @return スフィアマップがサポートされているならtrue
	 */
	virtual bool supportedTexgenSpheremap() const{ return texgenSpheremap_; }

	/**
	 * ローカルビューワ外はTexgen不可はサポートされているか
	 * @return ローカルビューワ外はTexgen不可がサポートされているならtrue
	 */
	virtual bool supportedNoTexgenNonLocalViewer() const{
		return noTexgenNonLocalViewer_;
	}

	//--------------------------------------------------------------------------
	// 頂点フォーマット
	//--------------------------------------------------------------------------
	/**
	 * FVFテクスチャ座標カウントマスクはサポートされているか
	 * @return FVFテクスチャ座標カウントマスクがサポートされているならtrue
	 */
	virtual bool supportedFvfTexCoordCountMask() const{
		return fvfTexCoordCountMask_;
	}

	/**
	 * FVF頂点に余分な要素を含められるはサポートされているか
	 * @return FVF頂点に余分な要素を含められるがサポートされているならtrue
	 */
	virtual bool supportedFvfDoNotStripElements() const{
		return fvfDoNotStripElements_;
	}

	/**
	 * FVF頂点サイズはサポートされているか
	 * @return FVF頂点サイズがサポートされているならtrue
	 */
	virtual bool supportedFvfPSize() const{ return fvfPSize_; }

	/**
	 * u_byte4宣言はサポートされているか
	 * @return u_byte4宣言がサポートされているならtrue
	 */
	virtual bool supportedDeclUByte4() const{ return declUByte4_; }

	/**
	 * u_byte4N宣言はサポートされているか
	 * @return u_byte4N宣言がサポートされているならtrue
	 */
	virtual bool supportedDeclUByte4N() const{ return declUByte4N_; }

	/**
	 * short2N宣言はサポートされているか
	 * @return short2N宣言がサポートされているならtrue
	 */
	virtual bool supportedDeclShort2N() const{ return declShort2N_; }

	/**
	 * short4N宣言はサポートされているか
	 * @return short4N宣言がサポートされているならtrue
	 */
	virtual bool supportedDeclShort4N() const{ return declShort4N_; }

	/**
	 * u_short2N宣言はサポートされているか
	 * @return u_short2N宣言がサポートされているならtrue
	 */
	virtual bool supportedDeclUShort2N() const{ return declUShort2N_; }

	/**
	 * u_short4N宣言はサポートされているか
	 * @return u_short4N宣言がサポートされているならtrue
	 */
	virtual bool supportedDeclUShort4N() const{ return declUShort4N_; }

	/**
	 * uDec3宣言はサポートされているか
	 * @return uDec3宣言がサポートされているならtrue
	 */
	virtual bool supportedDeclUDec3() const{ return declUDec3_; }

	/**
	 * dec3宣言はサポートされているか
	 * @return dec3宣言がサポートされているならtrue
	 */
	virtual bool supportedDeclDec3() const{ return declDec3_; }

	/**
	 * float16_2宣言はサポートされているか
	 * @return float16_2宣言がサポートされているならtrue
	 */
	virtual bool supportedDeclFloat16_2() const{ return declFloat16_2_; }

	/**
	 * float16_4宣言はサポートされているか
	 * @return float16_4宣言がサポートされているならtrue
	 */
	virtual bool supportedDeclFloat16_4() const{ return declFloat16_4_; }

	//--------------------------------------------------------------------------
	// テッセレーション
	//--------------------------------------------------------------------------
	/**
	 * Nパッチ最大分割レベルの取得
	 * @return Nパッチ最大分割レベル
	 */
	virtual float getMaxNPatchTesselationLevel() const{
		return maxNPatchTesselationLevel_;
	}

	/**
	 * ストリームオフセットはサポートされているか
	 * @return ストリームオフセットがサポートされているならtrue
	 */
	virtual bool supportedStreamOffset() const{ return streamOffset_; }

	/**
	 * ディスプレースメントNパッチはサポートされているか
	 * @return ディスプレースメントNパッチがサポートされているならtrue
	 */
	virtual bool supportedDmapNPatch() const{ return dmapNPatch_; }

	/**
	 *適応型RTパッチ はサポートされているか
	 * @return 適応型RTパッチがサポートされているならtrue
	 */
	virtual bool supportedAdaptiveTessRTPatch() const{
		return adaptiveTessRTPatch_;
	}

	/**
	 * 適応型Nパッチはサポートされているか
	 * @return 適応型Nパッチがサポートされているならtrue
	 */
	virtual bool supportedAdaptiveTessNPatch() const{
		return adaptiveTessNPatch_;
	}

	/**
	 * テクスチャからのStretchRectはサポートされているか
	 * @return テクスチャからのStretchRectがサポートされているならtrue
	 */
	virtual bool supportedCanStretchRectFromTextures() const{
		return canStretchRectFromTextures_;
	}

	/**
	 * プレディスプレースドNパッチはサポートされているか
	 * @return プレディスプレースドNパッチがサポートされているならtrue
	 */
	virtual bool supportedPreSampledDmapNPatch() const{
		return preSampledDmapNPatch_;
	}

	/**
	 * ストリームオフセット共有はサポートされているか
	 * @return ストリームオフセット共有がサポートされているならtrue
	 */
	virtual bool supportedVertexElementsCanShareStreamOffset() const{
		return vertexElementsCanShareStreamOffset_;
	}

	//--------------------------------------------------------------------------
	// シェーディング
	//--------------------------------------------------------------------------
	/**
	 * カラーグーロはサポートされているか
	 * @return カラーグーロがサポートされているならtrue
	 */
	virtual bool supportedShadeColorGouraudRGB() const{
		return shadeColorGouraudRGB_;
	}

	/**
	 * スペキュラグーロはサポートされているか
	 * @return スペキュラグーロがサポートされているならtrue
	 */
	virtual bool supportedShadeSpecularGouraudRGB() const{
		return shadeSpecularGouraudRGB_;
	}

	/**
	 * アルファグーロはサポートされているか
	 * @return アルファグーロがサポートされているならtrue
	 */
	virtual bool supportedShadeAlphaGouraudBlend() const{
		return shadeAlphaGouraudBlend_;
	}

	/**
	 * フォググーロはサポートされているか
	 * @return フォググーロがサポートされているならtrue
	 */
	virtual bool supportedShadeFogGouraud() const{ return shadeFogGouraud_; }

	//--------------------------------------------------------------------------
	// テクスチャ
	//--------------------------------------------------------------------------
	/**
	 * 最大テクスチャサイズの取得
	 * @return 最大テクスチャサイズ
	 */
	virtual const DimensionI& getMaxTextureSize() const{
		return maxTextureSize_;
	}

	/**
	 * 最大ボリュームテクスチャ辺の取得
	 * @return 最大ボリュームテクスチャ辺
	 */
	virtual u_int getMaxVolumeExtent() const{ return maxVolumeExtent_; }

	/**
	 * 最大テクスチャリピート数の取得
	 * @return 最大テクスチャリピート数
	 */
	virtual u_int getMaxTextureRepeat() const{ return maxTextureRepeat_; }

	/**
	 * 最大異方性フィルタ値の取得
	 * @return 最大異方性フィルタ値
	 */
	virtual u_int getMaxAnisotropy() const{ return maxAnisotropy_; }

	/**
	 * 最大テクスチャアスペクト比の取得
	 * @return 最大テクスチャアスペクト比
	 */
	virtual u_int getMaxTextureAspectRaito() const{
		return maxTextureAspectRaito_;
	}

	/**
	 * パースペクティブ補正はサポートされているか
	 * @return パースペクティブ補正がサポートされているならtrue
	 */
	virtual bool supportedTexturePerspective() const{
		return texturePerspective_;
	}

	/**
	 * 辺は2の累乗のみはサポートされているか
	 * @return 辺は2の累乗のみがサポートされているならtrue
	 */
	virtual bool supportedTexturePow2() const{ return texturePow2_; }

	/**
	 * アルファはサポートされているか
	 * @return アルファがサポートされているならtrue
	 */
	virtual bool supportedTextureAlpha() const{ return textureAlpha_; }

	/**
	 * 正方形のみはサポートされているか
	 * @return 正方形のみがサポートされているならtrue
	 */
	virtual bool supportedTextureSquareOnly() const{
		return textureSquareOnly_;
	}

	/**
	 * リピートスケール無しはサポートされているか
	 * @return リピートスケール無しがサポートされているならtrue
	 */
	virtual bool supportedTextureRepeatNotScaledBySize() const{
		return textureRepeatNotScaledBySize_;
	}

	/**
	 * アルファパレットはサポートされているか
	 * @return アルファパレットがサポートされているならtrue
	 */
	virtual bool supportedTextureAlphaPalette() const{
		return textureAlphaPalette_;
	}

	/**
	 * 辺は2の累乗で無くてよいはサポートされているか
	 * @return 辺は2の累乗で無くてよいがサポートされているならtrue
	 */
	virtual bool supportedTextureNonPow2Conditional() const{
		return textureNonPow2Conditional_;
	}

	/**
	 * 射影はサポートされているか
	 * @return 射影がサポートされているならtrue
	 */
	virtual bool supportedTextureProjected() const{ return textureProjected_; }

	/**
	 * キューブマップはサポートされているか
	 * @return キューブマップがサポートされているならtrue
	 */
	virtual bool supportedTextureCubemap() const{ return textureCubemap_; }

	/**
	 * ボリュームマップはサポートされているか
	 * @return ボリュームマップがサポートされているならtrue
	 */
	virtual bool supportedTextureVolumemap() const{ return textureVolumemap_; }

	/**
	 * ミップマップはサポートされているか
	 * @return ミップマップがサポートされているならtrue
	 */
	virtual bool supportedTextureMipmap() const{ return textureMipmap_; }

	/**
	 * キューブミップマップはサポートされているか
	 * @return キューブミップマップがサポートされているならtrue
	 */
	virtual bool supportedTextureMipmapCubemap() const{
		return textureMipmapCubemap_;
	}

	/**
	 * ボリュームミップマップはサポートされているか
	 * @return ボリュームミップマップがサポートされているならtrue
	 */
	virtual bool supportedTextureMipmapVolumemap() const{
		return textureMipmapVolumemap_;
	}

	/**
	 * キューブマップ辺は2の累乗のみはサポートされているか
	 * @return キューブマップ辺は2の累乗のみがサポートされているならtrue
	 */
	virtual bool supportedTextureCubemapPow2() const{
		return textureCubemapPow2_;
	}

	/**
	 * ボリュームマップ辺は2の累乗のみはサポートされているか
	 * @return ボリュームマップ辺は2の累乗のみがサポートされているならtrue
	 */
	virtual bool supportedTextureVolumemapPow2() const{
		return textureVolumemapPow2_;
	}

	/**
	 * 射影バンプ環境マップ無しはサポートされているか
	 * @return 射影バンプ環境マップ無しがサポートされているならtrue
	 */
	virtual bool supportedTextureNoProjectedBumpEnvironment() const{
		return textureNoProjectedBumpEnvironment_;
	}

	//--------------------------------------------------------------------------
	// テクスチャアドレス
	//--------------------------------------------------------------------------
	/**
	 * ラップはサポートされているか
	 * @return ラップがサポートされているならtrue
	 */
	virtual bool supportedTextureAddressWrap() const{
		return textureAddressWrap_;
	}

	/**
	 * ミラーはサポートされているか
	 * @return ミラーがサポートされているならtrue
	 */
	virtual bool supportedTextureAddressMirror() const{
		return textureAddressMirror_;
	}

	/**
	 * UVのクランプはサポートされているか
	 * @return UVのクランプがサポートされているならtrue
	 */
	virtual bool supportedTextureAddressClamp() const{
		return textureAddressClamp_;
	}

	/**
	 * 境界色の設定はサポートされているか
	 * @return 境界色の設定がサポートされているならtrue
	 */
	virtual bool supportedTextureAddressBorder() const{
		return textureAddressBorder_;
	}

	/**
	 * 独立UVモードはサポートされているか
	 * @return 独立UVモードがサポートされているならtrue
	 */
	virtual bool supportedTextureAddressIndependentUV() const{
		return textureAddressIndependentUV_;
	}

	/**
	 * 1制限ミラーはサポートされているか
	 * @return 1制限ミラーがサポートされているならtrue
	 */
	virtual bool supportedTextureAddressMirrorOnce() const{
		return textureAddressMirrorOnce_;
	}

	/**
	 * ボリュームラップはサポートされているか
	 * @return ボリュームラップがサポートされているならtrue
	 */
	virtual bool supportedVolumeTextureAddressWrap() const{
		return volumeTextureAddressWrap_;
	}

	/**
	 * ボリュームミラーはサポートされているか
	 * @return ボリュームミラーがサポートされているならtrue
	 */
	virtual bool supportedVolumeTextureAddressMirror() const{
		return volumeTextureAddressMirror_;
	}

	/**
	 * ボリュームUVのクランプはサポートされているか
	 * @return ボリュームUVのクランプがサポートされているならtrue
	 */
	virtual bool supportedVolumeTextureAddressClamp() const{
		return volumeTextureAddressClamp_;
	}

	/**
	 * ボリューム境界色の設定はサポートされているか
	 * @return ボリューム境界色の設定がサポートされているならtrue
	 */
	virtual bool supportedVolumeTextureAddressBorder() const{
		return volumeTextureAddressBorder_;
	}

	/**
	 * ボリューム独立UVモードはサポートされているか
	 * @return ボリューム独立UVモードがサポートされているならtrue
	 */
	virtual bool supportedVolumeTextureAddressIndependentUV() const{
		return volumeTextureAddressIndependentUV_;
	}

	/**
	 * ボリューム1制限ミラーはサポートされているか
	 * @return ボリューム1制限ミラーがサポートされているならtrue
	 */
	virtual bool supportedVolumeTextureAddressMirrorOnce() const{
		return volumeTextureAddressMirrorOnce_;
	}

	//--------------------------------------------------------------------------
	// テクスチャフィルタ
	//--------------------------------------------------------------------------
	/**
	 * 縮小ポイントはサポートされているか
	 * @return 縮小ポイントがサポートされているならtrue
	 */
	virtual bool supportedTextureFilterMinPoint() const{
		return textureFilterMinPoint_;
	}

	/**
	 * 縮小線形はサポートされているか
	 * @return 縮小線形がサポートされているならtrue
	 */
	virtual bool supportedTextureFilterMinLiner() const{
		return textureFilterMinLiner_;
	}

	/**
	 * 縮小異方性はサポートされているか
	 * @return 縮小異方性がサポートされているならtrue
	 */
	virtual bool supportedTextureFilterMinAnisotropic() const{
		return textureFilterMinAnisotropic_;
	}

	/**
	 * 縮小ピラミッドはサポートされているか
	 * @return 縮小ピラミッドがサポートされているならtrue
	 */
	virtual bool supportedTextureFilterMinPyramidalQuad() const{
		return textureFilterMinPyramidalQuad_;
	}

	/**
	 * 縮小2次ガウスはサポートされているか
	 * @return 縮小2次ガウスがサポートされているならtrue
	 */
	virtual bool supportedTextureFilterMinGaussianQuad() const{
		return textureFilterMinGaussianQuad_;
	}

	/**
	 * 拡大ポイントはサポートされているか
	 * @return 拡大ポイントがサポートされているならtrue
	 */
	virtual bool supportedTextureFilterMagPoint() const{
		return textureFilterMagPoint_;
	}

	/**
	 * 拡大線形はサポートされているか
	 * @return 拡大線形がサポートされているならtrue
	 */
	virtual bool supportedTextureFilterMagLiner() const{
		return textureFilterMagLiner_;
	}

	/**
	 * 拡大異方性はサポートされているか
	 * @return 拡大異方性がサポートされているならtrue
	 */
	virtual bool supportedTextureFilterMagAnisotropic() const{
		return textureFilterMagAnisotropic_;
	}

	/**
	 * 拡大ピラミッドはサポートされているか
	 * @return 拡大ピラミッドがサポートされているならtrue
	 */
	virtual bool supportedTextureFilterMagPyramidalQuad() const{
		return textureFilterMagPyramidalQuad_;
	}

	/**
	 * 拡大2次ガウスはサポートされているか
	 * @return 拡大2次ガウスがサポートされているならtrue
	 */
	virtual bool supportedTextureFilterMagGaussianQuad() const{
		return textureFilterMagGaussianQuad_;
	}

	/**
	 * ミップマップポイントはサポートされているか
	 * @return ミップマップポイントがサポートされているならtrue
	 */
	virtual bool supportedTextureFilterMipmapPoint() const{
		return textureFilterMipmapPoint_;
	}

	/**
	 * ミップマップ線形はサポートされているか
	 * @return ミップマップ線形がサポートされているならtrue
	 */
	virtual bool supportedTextureFilterMipmapLiner() const{
		return textureFilterMipmapLiner_;
	}

	//--------------------------------------------------------------------------
	/**
	 * キューブ縮小ポイントはサポートされているか
	 * @return キューブ縮小ポイントがサポートされているならtrue
	 */
	virtual bool supportedCubeTextureFilterMinPoint() const{
		return cubeTextureFilterMinPoint_;
	}

	/**
	 * キューブ縮小線形はサポートされているか
	 * @return キューブ縮小線形がサポートされているならtrue
	 */
	virtual bool supportedCubeTextureFilterMinLiner() const{
		return cubeTextureFilterMinLiner_;
	}

	/**
	 * キューブ縮小異方性はサポートされているか
	 * @return キューブ縮小異方性がサポートされているならtrue
	 */
	virtual bool supportedCubeTextureFilterMinAnisotropic() const{
		return cubeTextureFilterMinAnisotropic_;
	}

	/**
	 * キューブ縮小ピラミッドはサポートされているか
	 * @return キューブ縮小ピラミッドがサポートされているならtrue
	 */
	virtual bool supportedCubeTextureFilterMinPyramidalQuad() const{
		return cubeTextureFilterMinPyramidalQuad_;
	}

	/**
	 * キューブ縮小2次ガウスはサポートされているか
	 * @return キューブ縮小2次ガウスがサポートされているならtrue
	 */
	virtual bool supportedCubeTextureFilterMinGaussianQuad() const{
		return cubeTextureFilterMinGaussianQuad_;
	}

	/**
	 * キューブ拡大ポイントはサポートされているか
	 * @return キューブ拡大ポイントがサポートされているならtrue
	 */
	virtual bool supportedCubeTextureFilterMagPoint() const{
		return cubeTextureFilterMagPoint_;
	}

	/**
	 * キューブ拡大線形はサポートされているか
	 * @return キューブ拡大線形がサポートされているならtrue
	 */
	virtual bool supportedCubeTextureFilterMagLiner() const{
		return cubeTextureFilterMagLiner_;
	}

	/**
	 * キューブ拡大異方性はサポートされているか
	 * @return キューブ拡大異方性がサポートされているならtrue
	 */
	virtual bool supportedCubeTextureFilterMagAnisotropic() const{
		return cubeTextureFilterMagAnisotropic_;
	}

	/**
	 * キューブ拡大ピラミッドはサポートされているか
	 * @return キューブ拡大ピラミッドがサポートされているならtrue
	 */
	virtual bool supportedCubeTextureFilterMagPyramidalQuad() const{
		return cubeTextureFilterMagPyramidalQuad_;
	}

	/**
	 * キューブ拡大2次ガウスはサポートされているか
	 * @return キューブ拡大2次ガウスがサポートされているならtrue
	 */
	virtual bool supportedCubeTextureFilterMagGaussianQuad() const{
		return cubeTextureFilterMagGaussianQuad_;
	}

	/**
	 * キューブミップマップポイントはサポートされているか
	 * @return キューブミップマップポイントがサポートされているならtrue
	 */
	virtual bool supportedCubeTextureFilterMipmapPoint() const{
		return cubeTextureFilterMipmapPoint_;
	}

	/**
	 * キューブミップマップ線形はサポートされているか
	 * @return キューブミップマップ線形がサポートされているならtrue
	 */
	virtual bool supportedCubeTextureFilterMipmapLiner() const{
		return cubeTextureFilterMipmapLiner_;
	}

	//--------------------------------------------------------------------------
	/**
	 * ボリューム縮小ポイントはサポートされているか
	 * @return ボリューム縮小ポイントがサポートされているならtrue
	 */
	virtual bool supportedVolumeTextureFilterMinPoint() const{
		return volumeTextureFilterMinPoint_;
	}

	/**
	 * ボリューム縮小線形はサポートされているか
	 * @return ボリューム縮小線形がサポートされているならtrue
	 */
	virtual bool supportedVolumeTextureFilterMinLiner() const{
		return volumeTextureFilterMinLiner_;
	}

	/**
	 * ボリューム縮小異方性はサポートされているか
	 * @return ボリューム縮小異方性がサポートされているならtrue
	 */
	virtual bool supportedVolumeTextureFilterMinAnisotropic() const{
		return volumeTextureFilterMinAnisotropic_;
	}

	/**
	 * ボリューム縮小ピラミッドはサポートされているか
	 * @return ボリューム縮小ピラミッドがサポートされているならtrue
	 */
	virtual bool supportedVolumeTextureFilterMinPyramidalQuad() const{
		return volumeTextureFilterMinPyramidalQuad_;
	}

	/**
	 * ボリューム縮小2次ガウスはサポートされているか
	 * @return ボリューム縮小2次ガウスがサポートされているならtrue
	 */
	virtual bool supportedVolumeTextureFilterMinGaussianQuad() const{
		return volumeTextureFilterMinGaussianQuad_;
	}

	/**
	 * ボリューム拡大ポイントはサポートされているか
	 * @return ボリューム拡大ポイントがサポートされているならtrue
	 */
	virtual bool supportedVolumeTextureFilterMagPoint() const{
		return volumeTextureFilterMagPoint_;
	}

	/**
	 * ボリューム拡大線形はサポートされているか
	 * @return ボリューム拡大線形がサポートされているならtrue
	 */
	virtual bool supportedVolumeTextureFilterMagLiner() const{
		return volumeTextureFilterMagLiner_;
	}

	/**
	 * ボリューム拡大異方性はサポートされているか
	 * @return ボリューム拡大異方性がサポートされているならtrue
	 */
	virtual bool supportedVolumeTextureFilterMagAnisotropic() const{
		return volumeTextureFilterMagAnisotropic_;
	}

	/**
	 * ボリューム拡大ピラミッドはサポートされているか
	 * @return ボリューム拡大ピラミッドがサポートされているならtrue
	 */
	virtual bool supportedVolumeTextureFilterMagPyramidalQuad() const{
		return volumeTextureFilterMagPyramidalQuad_;
	}

	/**
	 * ボリューム拡大2次ガウスはサポートされているか
	 * @return ボリューム拡大2次ガウスがサポートされているならtrue
	 */
	virtual bool supportedVolumeTextureFilterMagGaussianQuad() const{
		return volumeTextureFilterMagGaussianQuad_;
	}

	/**
	 * ボリュームミップマップポイントはサポートされているか
	 * @return ボリュームミップマップポイントがサポートされているならtrue
	 */
	virtual bool supportedVolumeTextureFilterMipmapPoint() const{
		return volumeTextureFilterMipmapPoint_;
	}

	/**
	 * ボリュームミップマップ線形はサポートされているか
	 * @return ボリュームミップマップ線形がサポートされているならtrue
	 */
	virtual bool supportedVolumeTextureFilterMipmapLiner() const{
		return volumeTextureFilterMipmapLiner_;
	}

	//--------------------------------------------------------------------------
	/**
	 * 頂点縮小ポイントはサポートされているか
	 * @return 頂点縮小ポイントがサポートされているならtrue
	 */
	virtual bool supportedVertexTextureFilterMinPoint() const{
		return vertexTextureFilterMinPoint_;
	}

	/**
	 * 頂点縮小線形はサポートされているか
	 * @return 頂点縮小線形がサポートされているならtrue
	 */
	virtual bool supportedVertexTextureFilterMinLiner() const{
		return vertexTextureFilterMinLiner_;
	}

	/**
	 * 頂点縮小異方性はサポートされているか
	 * @return 頂点縮小異方性がサポートされているならtrue
	 */
	virtual bool supportedVertexTextureFilterMinAnisotropic() const{
		return vertexTextureFilterMinAnisotropic_;
	}

	/**
	 * 頂点縮小ピラミッドはサポートされているか
	 * @return 頂点縮小ピラミッドがサポートされているならtrue
	 */
	virtual bool supportedVertexTextureFilterMinPyramidalQuad() const{
		return vertexTextureFilterMinPyramidalQuad_;
	}

	/**
	 * 頂点縮小2次ガウスはサポートされているか
	 * @return 頂点縮小2次ガウスがサポートされているならtrue
	 */
	virtual bool supportedVertexTextureFilterMinGaussianQuad() const{
		return vertexTextureFilterMinGaussianQuad_;
	}

	/**
	 * 頂点拡大ポイントはサポートされているか
	 * @return 頂点拡大ポイントがサポートされているならtrue
	 */
	virtual bool supportedVertexTextureFilterMagPoint() const{
		return vertexTextureFilterMagPoint_;
	}

	/**
	 * 頂点拡大線形はサポートされているか
	 * @return 頂点拡大線形がサポートされているならtrue
	 */
	virtual bool supportedVertexTextureFilterMagLiner() const{
		return vertexTextureFilterMagLiner_;
	}

	/**
	 * 頂点拡大異方性はサポートされているか
	 * @return 頂点拡大異方性がサポートされているならtrue
	 */
	virtual bool supportedVertexTextureFilterMagAnisotropic() const{
		return vertexTextureFilterMagAnisotropic_;
	}

	/**
	 * 頂点拡大ピラミッドはサポートされているか
	 * @return 頂点拡大ピラミッドがサポートされているならtrue
	 */
	virtual bool supportedVertexTextureFilterMagPyramidalQuad() const{
		return vertexTextureFilterMagPyramidalQuad_;
	}

	/**
	 * 頂点拡大2次ガウスはサポートされているか
	 * @return 頂点拡大2次ガウスがサポートされているならtrue
	 */
	virtual bool supportedVertexTextureFilterMagGaussianQuad() const{
		return vertexTextureFilterMagGaussianQuad_;
	}

	/**
	 * 頂点ミップマップポイントはサポートされているか
	 * @return 頂点ミップマップポイントがサポートされているならtrue
	 */
	virtual bool supportedVertexTextureFilterMipmapPoint() const{
		return vertexTextureFilterMipmapPoint_;
	}

	/**
	 * 頂点ミップマップ線形はサポートされているか
	 * @return 頂点ミップマップ線形がサポートされているならtrue
	 */
	virtual bool supportedVertexTextureFilterMipmapLiner() const{
		return vertexTextureFilterMipmapLiner_;
	}

	//--------------------------------------------------------------------------
	// テクスチャステージ
	//--------------------------------------------------------------------------
	/**
	 * 最大テクスチャステージ数の取得
	 * @return 最大テクスチャステージ数
	 */
	virtual u_int getMaxTextureBlendStages() const{
		return maxTextureBlendStages_;
	}

	/**
	 * 最大マルチテクスチャ数の取得
	 * @return 最大マルチテクスチャ数
	 */
	virtual u_int getMaxSimultaneousTextures() const{
		return maxSimultaneousTextures_;
	}

	/**
	 * Disableオペレーションはサポートされているか
	 * @return Disableオペレーションがサポートされているならtrue
	 */
	virtual bool supportedTextureOperationDisable() const{
		return textureOperationDisable_;
	}

	/**
	 * SelectArg1オペレーションはサポートされているか
	 * @return SelectArg1オペレーションがサポートされているならtrue
	 */
	virtual bool supportedTextureOperationSelectArg1() const{
		return textureOperationSelectArg1_;
	}

	/**
	 * SelectArg2オペレーションはサポートされているか
	 * @return SelectArg2オペレーションがサポートされているならtrue
	 */
	virtual bool supportedTextureOperationSelectArg2() const{
		return textureOperationSelectArg2_;
	}

	/**
	 * Modulateオペレーションはサポートされているか
	 * @return Modulateオペレーションがサポートされているならtrue
	 */
	virtual bool supportedTextureOperationModulate() const{
		return textureOperationModulate_;
	}

	/**
	 * Modulate2xオペレーションはサポートされているか
	 * @return Modulate2xオペレーションがサポートされているならtrue
	 */
	virtual bool supportedTextureOperationModulate2x() const{
		return textureOperationModulate2x_;
	}

	/**
	 * Modulate4xオペレーションはサポートされているか
	 * @return Modulate4xオペレーションがサポートされているならtrue
	 */
	virtual bool supportedTextureOperationModulate4x() const{
		return textureOperationModulate4x_;
	}

	/**
	 * Addオペレーションはサポートされているか
	 * @return Addオペレーションがサポートされているならtrue
	 */
	virtual bool supportedTextureOperationAdd() const{
		return textureOperationAdd_;
	}

	/**
	 * AddSignedオペレーションはサポートされているか
	 * @return AddSignedオペレーションがサポートされているならtrue
	 */
	virtual bool supportedTextureOperationAddSigned() const{
		return textureOperationAddSigned_;
	}

	/**
	 * AddSigned2xオペレーションはサポートされているか
	 * @return AddSigned2xオペレーションがサポートされているならtrue
	 */
	virtual bool supportedTextureOperationAddSigned2x() const{
		return textureOperationAddSigned2x_;
	}

	/**
	 * Subtractオペレーションはサポートされているか
	 * @return Subtractオペレーションがサポートされているならtrue
	 */
	virtual bool supportedTextureOperationSubtract() const{
		return textureOperationSubtract_;
	}

	/**
	 * AddSmoothオペレーションはサポートされているか
	 * @return AddSmoothオペレーションがサポートされているならtrue
	 */
	virtual bool supportedTextureOperationAddSmooth() const{
		return textureOperationAddSmooth_;
	}

	/**
	 * BlendDiffuseAlphaオペレーションはサポートされているか
	 * @return BlendDiffuseAlphaオペレーションがサポートされているならtrue
	 */
	virtual bool supportedTextureOperationBlendDiffuseAlpha() const{
		return textureOperationBlendDiffuseAlpha_;
	}

	/**
	 * BlendTextureAlphaオペレーションはサポートされているか
	 * @return BlendTextureAlphaオペレーションがサポートされているならtrue
	 */
	virtual bool supportedTextureOperationBlendTextureAlpha() const{
		return textureOperationBlendTextureAlpha_;
	}

	/**
	 * BlendFactorAlphaオペレーションはサポートされているか
	 * @return BlendFactorAlphaオペレーションがサポートされているならtrue
	 */
	virtual bool supportedTextureOperationBlendFactorAlpha() const{
		return textureOperationBlendFactorAlpha_;
	}

	/**
	 * BlendTextureAlphaPMオペレーションはサポートされているか
	 * @return BlendTextureAlphaPMオペレーションがサポートされているならtrue
	 */
	virtual bool supportedTextureOperationBlendTextureAlphaPM() const{
		return textureOperationBlendTextureAlphaPM_;
	}

	/**
	 * BlendCurrentAlphaオペレーションはサポートされているか
	 * @return BlendCurrentAlphaオペレーションがサポートされているならtrue
	 */
	virtual bool supportedTextureOperationBlendCurrentAlpha() const{
		return textureOperationBlendCurrentAlpha_;
	}

	/**
	 * PreModulateオペレーションはサポートされているか
	 * @return PreModulateオペレーションがサポートされているならtrue
	 */
	virtual bool supportedTextureOperationPreModulate() const{
		return textureOperationPreModulate_;
	}

	/**
	 * ModulateAlphaAddColorオペレーションはサポートされているか
	 * @return ModulateAlphaAddColorオペレーションがサポートされているならtrue
	 */
	virtual bool supportedTextureOperationModulateAlphaAddColor() const{
		return textureOperationModulateAlphaAddColor_;
	}

	/**
	 * ModulateColorAddAlphaオペレーションはサポートされているか
	 * @return ModulateColorAddAlphaオペレーションがサポートされているならtrue
	 */
	virtual bool supportedTextureOperationModulateColorAddAlpha() const{
		return textureOperationModulateColorAddAlpha_;
	}

	/**
	 * ModulateInvAlphaAddColorオペレーションはサポートされているか
	 * @return ModulateInvAlphaAddColorオペレーションがサポートされているならtrue
	 */
	virtual bool supportedTextureOperationModulateInvAlphaAddColor() const{
		return textureOperationModulateInvAlphaAddColor_;
	}

	/**
	 * ModulateInvColorAddAlphaオペレーションはサポートされているか
	 * @return ModulateInvColorAddAlphaオペレーションがサポートされているならtrue
	 */
	virtual bool supportedTextureOperationModulateInvColorAddAlpha() const{
		return textureOperationModulateInvColorAddAlpha_;
	}

	/**
	 * BumpEnvMapオペレーションはサポートされているか
	 * @return BumpEnvMapオペレーションがサポートされているならtrue
	 */
	virtual bool supportedTextureOperationBumpEnvMap() const{
		return textureOperationBumpEnvMap_;
	}

	/**
	 * BumpEnvMapLuminanceオペレーションはサポートされているか
	 * @return BumpEnvMapLuminanceオペレーションがサポートされているならtrue
	 */
	virtual bool supportedTextureOperationBumpEnvMapLuminance() const{
		return textureOperationBumpEnvMapLuminance_;
	}

	/**
	 * DotProduct3オペレーションはサポートされているか
	 * @return DotProduct3オペレーションがサポートされているならtrue
	 */
	virtual bool supportedTextureOperationDotProduct3() const{
		return textureOperationDotProduct3_;
	}

	/**
	 * MultiplyAddオペレーションはサポートされているか
	 * @return MultiplyAddオペレーションがサポートされているならtrue
	 */
	virtual bool supportedTextureOperationMultiplyAdd() const{
		return textureOperationMultiplyAdd_;
	}

	/**
	 * Lerpオペレーションはサポートされているか
	 * @return Lerpオペレーションがサポートされているならtrue
	 */
	virtual bool supportedTextureOperationLerp() const{
		return textureOperationLerp_;
	}

	//--------------------------------------------------------------------------
	// 比較
	//--------------------------------------------------------------------------
	/**
	 * Z比較Neverはサポートされているか
	 * @return Z比較Neverがサポートされているならtrue
	 */
	virtual bool supportedZCompareNever() const{ return zCompareNever_; }

	/**
	 * Z比較Lessはサポートされているか
	 * @return Z比較Lessがサポートされているならtrue
	 */
	virtual bool supportedZCompareLess() const{ return zCompareLess_; }

	/**
	 * Z比較Equalはサポートされているか
	 * @return Z比較Equalがサポートされているならtrue
	 */
	virtual bool supportedZCompareEqual() const{ return zCompareEqual_; }

	/**
	 * Z比較LessEqualはサポートされているか
	 * @return Z比較LessEqualがサポートされているならtrue
	 */
	virtual bool supportedZCompareLessEqual() const{
		return zCompareLessEqual_;
	}

	/**
	 * Z比較Greaterはサポートされているか
	 * @return Z比較Greaterがサポートされているならtrue
	 */
	virtual bool supportedZCompareGreater() const{ return zCompareGreater_; }

	/**
	 * Z比較NotEqualはサポートされているか
	 * @return がZ比較NotEqualサポートされているならtrue
	 */
	virtual bool supportedZCompareNotEqual() const{ return zCompareNotEqual_; }

	/**
	 * Z比較GreaterEqualはサポートされているか
	 * @return Z比較GreaterEqualがサポートされているならtrue
	 */
	virtual bool supportedZCompareGreaterEqual() const{
		return zCompareGreaterEqual_;
	}

	/**
	 * Z比較Alwaysはサポートされているか
	 * @return Z比較Alwaysがサポートされているならtrue
	 */
	virtual bool supportedZCompareAlways() const{ return zCompareAlways_; }

	//--------------------------------------------------------------------------
	/**
	 * ステンシルKeepはサポートされているか
	 * @return ステンシルKeepがサポートされているならtrue
	 */
	virtual bool supportedStencilKeep() const{ return stencilKeep_; }

	/**
	 * ステンシルZeroはサポートされているか
	 * @return ステンシルZeroがサポートされているならtrue
	 */
	virtual bool supportedStencilZero() const{ return stencilZero_; }

	/**
	 * ステンシルReplaceはサポートされているか
	 * @return ステンシルReplaceがサポートされているならtrue
	 */
	virtual bool supportedStencilReplace() const{ return stencilReplace_; }

	/**
	 * ステンシルIncrSatはサポートされているか
	 * @return ステンシルIncrSatがサポートされているならtrue
	 */
	virtual bool supportedStencilIncrSat() const{ return stencilIncrSat_; }

	/**
	 * ステンシルDecrSatはサポートされているか
	 * @return ステンシルDecrSatがサポートされているならtrue
	 */
	virtual bool supportedStencilDecrSat() const{ return stencilDecrSat_; }

	/**
	 * ステンシルInvertはサポートされているか
	 * @return ステンシルInvertがサポートされているならtrue
	 */
	virtual bool supportedStencilInvert() const{ return stencilInvert_; }

	/**
	 * ステンシルIncrはサポートされているか
	 * @return ステンシルIncrがサポートされているならtrue
	 */
	virtual bool supportedStencilIncr() const{ return stencilIncr_; }

	/**
	 * ステンシルDecrはサポートされているか
	 * @return ステンシルDecrがサポートされているならtrue
	 */
	virtual bool supportedStencilDecr() const{ return stencilDecr_; }

	/**
	 * ステンシルTwoSidedはサポートされているか
	 * @return ステンシルTwoSidedがサポートされているならtrue
	 */
	virtual bool supportedStencilTwoSided() const{ return stencilTwoSided_; }

	//--------------------------------------------------------------------------
	/**
	 * アルファ比較Neverはサポートされているか
	 * @return アルファ比較Neverがサポートされているならtrue
	 */
	virtual bool supportedAlphaCompareNever() const{
		return alphaCompareNever_;
	}

	/**
	 * アルファ比較Lessはサポートされているか
	 * @return アルファ比較Lessがサポートされているならtrue
	 */
	virtual bool supportedAlphaCompareLess() const{ return alphaCompareLess_; }

	/**
	 * アルファ比較Equalはサポートされているか
	 * @return アルファ比較Equalがサポートされているならtrue
	 */
	virtual bool supportedAlphaCompareEqual() const{
		return alphaCompareEqual_;
	}

	/**
	 * アルファ比較LessEqualはサポートされているか
	 * @return アルファ比較LessEqualがサポートされているならtrue
	 */
	virtual bool supportedAlphaCompareLessEqual() const{
		return alphaCompareLessEqual_;
	}

	/**
	 * アルファ比較Greaterはサポートされているか
	 * @return アルファ比較Greaterがサポートされているならtrue
	 */
	virtual bool supportedAlphaCompareGreater() const{
		return alphaCompareGreater_;
	}

	/**
	 * アルファ比較NotEqualはサポートされているか
	 * @return がアルファ比較NotEqualサポートされているならtrue
	 */
	virtual bool supportedAlphaCompareNotEqual() const{
		return alphaCompareNotEqual_;
	}

	/**
	 * アルファ比較GreaterEqualはサポートされているか
	 * @return アルファ比較GreaterEqualがサポートされているならtrue
	 */
	virtual bool supportedAlphaCompareGreaterEqual() const{
		return alphaCompareGreaterEqual_;
	}

	/**
	 * アルファ比較Alwaysはサポートされているか
	 * @return アルファ比較Alwaysがサポートされているならtrue
	 */
	virtual bool supportedAlphaCompareAlways() const{
		return alphaCompareAlways_;
	}

	//--------------------------------------------------------------------------
	// ブレンディング
	//--------------------------------------------------------------------------
	/**
	 * ソースZeroはサポートされているか
	 * @return ソースZeroがサポートされているならtrue
	 */
	virtual bool supportedBlendSourceZero() const{ return blendSourceZero_; }

	/**
	 * ソースOneはサポートされているか
	 * @return ソースOneがサポートされているならtrue
	 */
	virtual bool supportedBlendSourceOne() const{ return blendSourceOne_; }

	/**
	 * ソースSrcColorはサポートされているか
	 * @return ソースSrcColorがサポートされているならtrue
	 */
	virtual bool supportedBlendSourceSrcColor() const{
		return blendSourceSrcColor_;
	}

	/**
	 * ソースInvSrcColorはサポートされているか
	 * @return ソースInvSrcColorがサポートされているならtrue
	 */
	virtual bool supportedBlendSourceInvSrcColor() const{
		return blendSourceInvSrcColor_;
	}

	/**
	 * ソースSrcAlphaはサポートされているか
	 * @return ソースSrcAlphaがサポートされているならtrue
	 */
	virtual bool supportedBlendSourceSrcAlpha() const{
		return blendSourceSrcAlpha_;
	}

	/**
	 * ソースInvSrcAlphaはサポートされているか
	 * @return ソースInvSrcAlphaがサポートされているならtrue
	 */
	virtual bool supportedBlendSourceInvSrcAlpha() const{
		return blendSourceInvSrcAlpha_;
	}

	/**
	 * ソースDestAlphaはサポートされているか
	 * @return ソースDestAlphaがサポートされているならtrue
	 */
	virtual bool supportedBlendSourceDestAlpha() const{
		return blendSourceDestAlpha_;
	}

	/**
	 * ソースInvDestAlphaはサポートされているか
	 * @return ソースInvDestAlphaがサポートされているならtrue
	 */
	virtual bool supportedBlendSourceInvDestAlpha() const{
		return blendSourceInvDestAlpha_;
	}

	/**
	 * ソースDestColorはサポートされているか
	 * @return ソースDestColorがサポートされているならtrue
	 */
	virtual bool supportedBlendSourceDestColor() const{
		return blendSourceDestColor_;
	}

	/**
	 * ソースInvDestColorはサポートされているか
	 * @return ソースInvDestColorがサポートされているならtrue
	 */
	virtual bool supportedBlendSourceInvDestColor() const{
		return blendSourceInvDestColor_;
	}

	/**
	 * ソースSrcAlphaSatはサポートされているか
	 * @return ソースSrcAlphaSatがサポートされているならtrue
	 */
	virtual bool supportedBlendSourceSrcAlphaSat() const{
		return blendSourceSrcAlphaSat_;
	}

	/**
	 * ソースBothSrcAlphaはサポートされているか
	 * @return ソースBothSrcAlphaがサポートされているならtrue
	 */
	virtual bool supportedBlendSourceBothSrcAlpha() const{
		return blendSourceBothSrcAlpha_;
	}

	/**
	 * ソースBothInvSrcAlphaはサポートされているか
	 * @return ソースBothInvSrcAlphaがサポートされているならtrue
	 */
	virtual bool supportedBlendSourceBothInvSrcAlpha() const{
		return blendSourceBothInvSrcAlpha_;
	}

	/**
	 * ソースBlendFactorはサポートされているか
	 * @return ソースBlendFactorがサポートされているならtrue
	 */
	virtual bool supportedBlendSourceBlendFactor() const{
		return blendSourceBlendFactor_;
	}

	//--------------------------------------------------------------------------
	/**
	 * デスティネーションZeroはサポートされているか
	 * @return デスティネーションZeroがサポートされているならtrue
	 */
	virtual bool supportedBlendDestinationZero() const{
		return blendDestinationZero_;
	}

	/**
	 * デスティネーションOneはサポートされているか
	 * @return デスティネーションOneがサポートされているならtrue
	 */
	virtual bool supportedBlendDestinationOne() const{
		return blendDestinationOne_;
	}

	/**
	 * デスティネーションSrcColorはサポートされているか
	 * @return デスティネーションSrcColorがサポートされているならtrue
	 */
	virtual bool supportedBlendDestinationSrcColor() const{
		return blendDestinationSrcColor_;
	}

	/**
	 * デスティネーションInvSrcColorはサポートされているか
	 * @return デスティネーションInvSrcColorがサポートされているならtrue
	 */
	virtual bool supportedBlendDestinationInvSrcColor() const{
		return blendDestinationInvSrcColor_;
	}

	/**
	 * デスティネーションSrcAlphaはサポートされているか
	 * @return デスティネーションSrcAlphaがサポートされているならtrue
	 */
	virtual bool supportedBlendDestinationSrcAlpha() const{
		return blendDestinationSrcAlpha_;
	}

	/**
	 * デスティネーションInvSrcAlphaはサポートされているか
	 * @return デスティネーションInvSrcAlphaがサポートされているならtrue
	 */
	virtual bool supportedBlendDestinationInvSrcAlpha() const{
		return blendDestinationInvSrcAlpha_;
	}

	/**
	 * デスティネーションDestAlphaはサポートされているか
	 * @return デスティネーションDestAlphaがサポートされているならtrue
	 */
	virtual bool supportedBlendDestinationDestAlpha() const{
		return blendDestinationDestAlpha_;
	}

	/**
	 * デスティネーションInvDestAlphaはサポートされているか
	 * @return デスティネーションInvDestAlphaがサポートされているならtrue
	 */
	virtual bool supportedBlendDestinationInvDestAlpha() const{
		return blendDestinationInvDestAlpha_;
	}

	/**
	 * デスティネーションDestColorはサポートされているか
	 * @return デスティネーションDestColorがサポートされているならtrue
	 */
	virtual bool supportedBlendDestinationDestColor() const{
		return blendDestinationDestColor_;
	}

	/**
	 * デスティネーションInvDestColorはサポートされているか
	 * @return デスティネーションInvDestColorがサポートされているならtrue
	 */
	virtual bool supportedBlendDestinationInvDestColor() const{
		return blendDestinationInvDestColor_;
	}

	/**
	 * デスティネーションSrcAlphaSatはサポートされているか
	 * @return デスティネーションSrcAlphaSatがサポートされているならtrue
	 */
	virtual bool supportedBlendDestinationSrcAlphaSat() const{
		return blendDestinationSrcAlphaSat_;
	}

	/**
	 * デスティネーションBothSrcAlphaはサポートされているか
	 * @return デスティネーションBothSrcAlphaがサポートされているならtrue
	 */
	virtual bool supportedBlendDestinationBothSrcAlpha() const{
		return blendDestinationBothSrcAlpha_;
	}

	/**
	 * デスティネーションBothInvSrcAlphaはサポートされているか
	 * @return デスティネーションBothInvSrcAlphaがサポートされているならtrue
	 */
	virtual bool supportedBlendDestinationBothInvSrcAlpha() const{
		return blendDestinationBothInvSrcAlpha_;
	}

	/**
	 * デスティネーションBlendFactorはサポートされているか
	 * @return デスティネーションBlendFactorがサポートされているならtrue
	 */
	virtual bool supportedBlendDestinationBlendFactor() const{
		return blendDestinationBlendFactor_;
	}

	//--------------------------------------------------------------------------
	// ラスタライズ
	//--------------------------------------------------------------------------
	/**
	 * アンチエイリアス拡張の取得
	 * @return アンチエイリアス拡張
	 */
	virtual float getExtentsAdjust() const{ return extentsAdjust_; }

	/**
	 * ディザはサポートされているか
	 * @return ディザがサポートされているならtrue
	 */
	virtual bool supportedRasterDither() const{ return rasterDither_; }

	/**
	 * Zテストはサポートされているか
	 * @return Zテストがサポートされているならtrue
	 */
	virtual bool supportedRasterZTest() const{ return rasterZTest_; }

	/**
	 * 頂点フォグはサポートされているか
	 * @return 頂点フォグがサポートされているならtrue
	 */
	virtual bool supportedRasterFogVertex() const{ return rasterFogVertex_; }

	/**
	 * フォグテーブルはサポートされているか
	 * @return フォグテーブルがサポートされているならtrue
	 */
	virtual bool supportedRasterFogTable() const{ return rasterFogTable_; }

	/**
	 * ミップマップバイアスはサポートされているか
	 * @return ミップマップバイアスがサポートされているならtrue
	 */
	virtual bool supportedRasterMipmapLODBias() const{
		return rasterMipmapLODBias_;
	}

	/**
	 * 隠れ面消去はサポートされているか
	 * @return 隠れ面消去がサポートされているならtrue
	 */
	virtual bool supportedRasterZBufferLessHSR() const{
		return rasterZBufferLessHSR_;
	}

	/**
	 * レンジフォグはサポートされているか
	 * @return レンジフォグがサポートされているならtrue
	 */
	virtual bool supportedRasterFogRange() const{ return rasterFogRange_; }

	/**
	 * 異方性フィルタリングはサポートされているか
	 * @return 異方性フィルタリングがサポートされているならtrue
	 */
	virtual bool supportedRasterAnisotropy() const{ return rasterAnisotropy_; }

	/**
	 * Wバッファはサポートされているか
	 * @return Wバッファがサポートされているならtrue
	 */
	virtual bool supportedRasterWBuffer() const{ return rasterWBuffer_; }

	/**
	 * Wフォグはサポートされているか
	 * @return Wフォグがサポートされているならtrue
	 */
	virtual bool supportedRasterWFog() const{ return rasterWFog_; }

	/**
	 * Zフォグはサポートされているか
	 * @return Zフォグがサポートされているならtrue
	 */
	virtual bool supportedRasterZFog() const{ return rasterZFog_; }

	/**
	 * 色パースペクティブ補正はサポートされているか
	 * @return 色パースペクティブ補正がサポートされているならtrue
	 */
	virtual bool supportedRasterColorPerspective() const{
		return rasterColorPerspective_;
	}

	/**
	 * シザーテストはサポートされているか
	 * @return シザーテストがサポートされているならtrue
	 */
	virtual bool supportedRasterScissorTest() const{
		return rasterScissorTest_;
	}

	/**
	 * スロープスケール深度バイアスはサポートされているか
	 * @return スロープスケール深度バイアスがサポートされているならtrue
	 */
	virtual bool supportedRasterSlopeScaleDepthBias() const{
		return rasterSlopeScaleDepthBias_;
	}

	/**
	 * 深度バイアスはサポートされているか
	 * @return 深度バイアスがサポートされているならtrue
	 */
	virtual bool supportedRasterDepthBias() const{ return rasterDepthBias_; }

	/**
	 * マルチサンプル切り替えはサポートされているか
	 * @return マルチサンプル切り替えがサポートされているならtrue
	 */
	virtual bool supportedRasterMultiSampleToggle() const{
		return rasterMultiSampleToggle_;
	}

	//--------------------------------------------------------------------------
	// 頂点シェーダ
	//--------------------------------------------------------------------------
	/**
	 * 頂点シェーダメジャーバージョンの取得
	 * @return 頂点シェーダメジャーバージョン
	 */
	virtual u_int getVertexShaderMajorVersion() const{
		return vertexShaderMajorVersion_;
	}

	/**
	 * 頂点シェーダマイナーバージョンの取得
	 * @return 頂点シェーダマイナーバージョン
	 */
	virtual u_int getVertexShaderMinorVersion() const{
		return vertexShaderMinorVersion_;
	}

	/**
	 * 最大頂点シェーダ定数の取得
	 * @return 最大頂点シェーダ定数
	 */
	virtual u_int getMaxVertexShaderConst() const{
		return maxVertexShaderConst_;
	}

	/**
	 * 最大ストリームストライド数の取得
	 * @return 最大ストリームストライド数
	 */
	virtual u_int getMaxStreamStride() const{ return maxStreamStride_; }

 	/**
	 * 最大命令実行数数の取得
	 * @return 最大命令実行数
	 */
	virtual u_int getMaxVShaderInstructionsExecuted() const{
		return maxVShaderInstructionsExecuted_;
	}

 	/**
	 * 最大命令スロット数の取得
	 * @return 最大命令スロット数
	 */
	virtual u_int getMaxVertexShader30InstructionSlots() const{
		return maxVertexShader30InstructionSlots_;
	}

 	/**
	 * 動的フローネストレベルの取得
	 * @return 動的フローネストレベル
	 */
	virtual u_int getVertexShaderDynamicFlowControlDepth() const{
		return vertexShaderDynamicFlowControlDepth_;
	}

 	/**
	 * テンポラリ数の取得
	 * @return テンポラリ数
	 */
	virtual u_int getVertexShaderNumTemps() const{
		return vertexShaderNumTemps_;
	}

 	/**
	 * 静的フローネストレベルの取得
	 * @return 静的フローネストレベル
	 */
	virtual u_int getVertexShaderStaticFlowControlDepth() const{
		return vertexShaderStaticFlowControlDepth_;
	}

	/**
	 * プレディケーション命令はサポートされているか
	 * @return プレディケーション命令がサポートされているならtrue
	 */
	virtual bool supportedVertexShaderPredication() const{
		return vertexShaderPredication_;
	}

	//--------------------------------------------------------------------------
	// ピクセルシェーダ
	//--------------------------------------------------------------------------
	/**
	 * ピクセルシェーダメジャーバージョンの取得
	 * @return ピクセルシェーダメジャーバージョン
	 */
	virtual u_int getPixelShaderMajorVersion() const{
		return pixelShaderMajorVersion_;
	}

	/**
	 * ピクセルシェーダマイナーバージョンの取得
	 * @return ピクセルシェーダマイナーバージョン
	 */
	virtual u_int getPixelShaderMinorVersion() const{
		return pixelShaderMinorVersion_;
	}

	/**
	 * ピクセルシェーダ1x最大値の取得
	 * @return ピクセルシェーダ1x最大値
	 */
	virtual float getPixelShader1xMaxValue() const{
		return pixelShader1xMaxValue_;
	}

 	/**
	 * 最大命令実行数数の取得
	 * @return 最大命令実行数
	 */
	virtual u_int getMaxPShaderInstructionsExecuted() const{
		return maxPShaderInstructionsExecuted_;
	}

 	/**
	 * 最大命令スロット数の取得
	 * @return 最大命令スロット数
	 */
	virtual u_int getMaxPixelShader30InstructionSlots() const{
		return maxPixelShader30InstructionSlots_;
	}

 	/**
	 * 動的フローネストレベルの取得
	 * @return 動的フローネストレベル
	 */
	virtual u_int getPixelShaderDynamicFlowControlDepth() const{
		return pixelShaderDynamicFlowControlDepth_;
	}

 	/**
	 * テンポラリ数の取得
	 * @return テンポラリ数
	 */
	virtual u_int getPixelShaderNumTemps() const{
		return pixelShaderNumTemps_;
	}

 	/**
	 * 静的フローネストレベルの取得
	 * @return 静的フローネストレベル
	 */
	virtual u_int getPixelShaderStaticFlowControlDepth() const{
		return pixelShaderStaticFlowControlDepth_;
	}

 	/**
	 * 命令スロット数の取得
	 * @return 命令スロット数
	 */
	virtual u_int getPixelShaderNumInstructionSlots() const{
		return pixelShaderNumInstructionSlots_;
	}

	/**
	 * 任意の入れ替えはサポートされているか
	 * @return 任意の入れ替えがサポートされているならtrue
	 */
	virtual bool supportedPixelShaderArbitrarySwizzle() const{
		return pixelShaderArbitrarySwizzle_;
	}

	/**
	 * グラデーション命令はサポートされているか
	 * @return グラデーション命令がサポートされているならtrue
	 */
	virtual bool supportedPixelShaderGradientInstructions() const{
		return pixelShaderGradientInstructions_;
	}

	/**
	 * プレディケーション命令はサポートされているか
	 * @return プレディケーション命令がサポートされているならtrue
	 */
	virtual bool supportedPixelShaderPredication() const{
		return pixelShaderPredication_;
	}

	/**
	 * 従属読み込み無制限はサポートされているか
	 * @return 従属読み込み無制限がサポートされているならtrue
	 */
	virtual bool supportedPixelShaderNoDependentReadLimit() const{
		return pixelShaderNoDependentReadLimit_;
	}

	/**
	 * tex命令無制限はサポートされているか
	 * @return tex命令無制限がサポートされているならtrue
	 */
	virtual bool supportedPixelShaderNoTexnstructionLimit() const{
		return pixelShaderNoTexnstructionLimit_;
	}

	//--------------------------------------------------------------------------
protected:
	/**
	 * コンストラクタ
	 */
	GraphicsDeviceCapacity();

	/**
	 * デストラクタ
	 */
	virtual ~GraphicsDeviceCapacity();

	/**
	 * デバイスがリセットされた
	 * @param direct3DDevice Direct3Dデバイス
	 */
	virtual void deviceReset(Direct3DDevice* direct3DDevice);

	/**
	 * サポート文字列の取得
	 * @param supported サポートフラグ
	 * @return 文字列
	 */
	virtual String supportedString(bool supported) const{
		if(supported){ return "○\n"; }
		return "×\n";
	}

	//--------------------------------------------------------------------------
private:
	// コピーコンストラクタの隠蔽
	GraphicsDeviceCapacity(const GraphicsDeviceCapacity& copy);

	// 代入コピーの隠蔽
	void operator =(const GraphicsDeviceCapacity& copy);

	// デバイス能力
	D3DCapacity capacity_;

	// インスタンス
	static GraphicsDeviceCapacity* instance_;

	//--------------------------------------------------------------------------
	// デバイス情報
	//--------------------------------------------------------------------------
	// デバイス名
	String deviceName_;
	// ドライバ名
	String driverName_;
	// デバイス番号
	int deviceOrdinal_;
	// デバイスタイプ
	D3DDEVTYPE deviceType_;
	// ウィンドウモードか
	bool isWindowed_;
	// 頂点プロセスタイプ
	VertexProcessingType vertexProcessingType_;
	// アダプタフォーマット
	D3DFORMAT adapterFormat_;
	// バックバッファフォーマット
	D3DFORMAT backBufferFormat_;
	// バックバッファサイズ
	DimensionI backBufferSize_;
	// リフレッシュレート
	int refreshRate_;
	// 深度、ステンシルバッファは有効か
	bool depthStencilEnabled_;
	// 深度、ステンシルフォーマット
	D3DFORMAT depthStencilFormat_;
	// プレゼンテーション間隔
	u_int presentationInterval_;
	// マルチサンプルタイプ
	D3DMULTISAMPLE_TYPE multiSampleType_;
	// マルチサンプルクォリティ
	u_int multiSampleQuality_;

	//--------------------------------------------------------------------------
	// デバイス能力
	//--------------------------------------------------------------------------
	// マルチレンダーターゲット数
	u_int numSimultaneousRTs_;
	// システムメモリで実行
	bool executeSystemMemory_;
	// ビデオメモリで実行
	bool executeVideoMemory_;
	// システムメモリ上のTL頂点
	bool tlVertexSystemMemory_;
	// ビデオメモリ上のTL頂点
	bool tlVertexVideoMemory_;
	// システムメモリ上のテクスチャ
	bool textureSystemMemory_;
	// ビデオメモリ上のテクスチャ
	bool textureVideoMemory_;
	// TL頂点の描画
	bool drawPrimTlVertex_;
	// フリップ後のレンダリング
	bool canRenderAfterFlip_;
	// 非ローカルビデオメモリ
	bool textureNonLocalVidedMemory_;
	// DrawPrivitives2
	bool drawPrimitives2_;
	// 独立したテクスチャメモリプール
	bool separateTextureMemories_;
	// DrawPrimitives2EX
	bool drawPrimitives2EX_;
	// ハードウェアT&L
	bool hwTransformAndLight_;
	// システムからビデオへのBLT
	bool canBltSystemToNonLocal_;
	// ハードウェアラスタライズ
	bool hwRasterization_;
	// ピュアデバイス
	bool pureDevice_;
	// ベジェ、Bスプライン
	bool quinticRtPatches_;
	// 矩形、三角形パッチ
	bool rtPatches_;
	// 効率的なハンドル0パッチ
	bool rtPatchHanldeZero_;
	// Nパッチ
	bool nPatches_;
	// プレゼンテーション間隔即時
	bool presentationIntervalImmediate_;
	// プレゼンテーション間隔1垂直同期
	bool presentationIntervalOne_;
	// プレゼンテーション間隔2垂直同期
	bool presentationIntervalTwo_;
	// プレゼンテーション間隔3垂直同期
	bool presentationIntervalThree_;
	// プレゼンテーション間隔4垂直同期
	bool presentationIntervalFour_;
	// ハードウェアカーソル
	bool cursorColor_;
	// 低解像度ハードウェアカーソル
	bool cursorLowRes_;
	// StretchRectMinPointフィルタ
	bool stretchRectMinPoint_;
	// StretchRectMagPointフィルタ
	bool stretchRectMagPoint_;
	// StretchRectMinLinearフィルタ
	bool stretchRectMinLinear_;
	// StretchRectMagLinearフィルタ
	bool stretchRectMagLinear_;

	//--------------------------------------------------------------------------
	// デバイスその他
	//--------------------------------------------------------------------------
	// マスターアダプタ番号
	u_int masterAdapterOrdinal_;
	// グループ内のアダプタ番号
	u_int adapterOrdinalInGroup_;
	// グループのアダプタ数
	u_int numberOfAdaptersInGroup_;
	// Zマスク
	bool maskZ_;
	// カリング無し
	bool cullNone_;
	// 時計回りカリング
	bool cullCW_;
	// 反時計回りカリング
	bool cullCCW_;
	// カラーチャンネル書き込み
	bool colorWriteEnable_;
	// 正確なポイントクリップ
	bool clipPlaneScaledPoints_;
	// 頂点クリップ
	bool clipTlVerts_;
	// テンポラリテクスチャ引数
	bool tssArgTemp_;
	// アルファブレンディング
	bool blendOp_;
	// ヌルリファレンス
	bool nullReference_;
	// 独立した書き込みマスク
	bool independentWriteMasks_;
	// テクスチャステージ定数
	bool perStageConstant_;
	// フォグとスペキュラアルファ
	bool fogAndSpecularAlpha_;
	// アルファ用ブレンド
	bool separateAlphaBlend_;
	// MRTに違うZ深度
	bool mrtIndependentBitDepth_;
	// MRTにピクセルシェーダ後処理
	bool mrtPostPixelShaderBlending_;
	// 頂点フォグのクランプ
	bool fogVertexClamped_;

	//--------------------------------------------------------------------------
	// ドライバ能力
	//--------------------------------------------------------------------------
	// スキャンラインの読み込み
	bool readScanLine_;
	// フルスクリーンガンマ
	bool fullscreenGamma_;
	// キャリブレートガンマ
	bool canCalibrateGamma_;
	// マネージドリソース
	bool canManageResource_;
	// 動的テクスチャ
	bool dynamicTextures_;
	// ミップマップ自動生成
	bool canAutogenMipmap_;
	// フルスクリーンアルファブレンド
	bool alphaFullscreenFlipOrDiscard_;
	// sRGBプレゼンテーション
	bool linerToSrgbPresentation_;
	// ビデオメモリへのコピー
	bool copyToVideoMemory_;
	// システムメモリへのコピー
	bool copyToSystemMemory_;

	//--------------------------------------------------------------------------
	// プリミティブ
	//--------------------------------------------------------------------------
	// 最大点サイズ
	float maxPointSize_;
	// ラインテクスチャ
	bool lineTexture_;
	// ラインZテスト
	bool lineZTest_;
	// ラインブレンド
	bool lineBlend_;
	// ラインアルファ比較
	bool lineAlphaCompare_;
	// ラインフォグ
	bool lineFog_;
	// ラインアンチエイリアス
	bool lineAntialias_;

	//--------------------------------------------------------------------------
	// 頂点処理
	//--------------------------------------------------------------------------
	// 最大プリミティブ数
	u_int maxPrimitiveCount_;
	// 最大インデックス数
	u_int maxVertexIndex_;
	// 最大ストリーム数
	u_int maxStreams_;
	// 最大ライト数
	u_int maxActiveLights_;
	// 最大W値
	float maxVertexW_;
	// 最大ブレンド行列数
	u_int maxVertexBlendMatrices_;
	// 最大ブレンド行列インデックス数
	u_int maxVertexBlendMatrixIndex_;
	// ガードバンド左
	float guardBandLeft_;
	// ガードバンド上
	float guardBandTop_;
	// ガードバンド右
	float guardBandRight_;
	// ガードバンド下
	float guardBandBottom_;
	// 最大ユーザクリップ面
	u_int maxUserCliplanes_;
	// Texgen
	bool texGen_;
	// カラーマテリアルソース
	bool materialSource_;
	// ディレクショナルライト
	bool directionalLights_;
	// ポジションライト
	bool positionalLights_;
	// ローカルビューワ
	bool localViewer_;
	// 頂点トゥイーニング
	bool tweening_;
	// スフィアマップ
	bool texgenSpheremap_;
	// ローカルビューワ外はTexgen不可
	bool noTexgenNonLocalViewer_;

	//--------------------------------------------------------------------------
	// 頂点フォーマット
	//--------------------------------------------------------------------------
	// FVFテクスチャ座標カウントマスク
	bool fvfTexCoordCountMask_;
	// FVF頂点に余分な要素を含められる
	bool fvfDoNotStripElements_;
	// FVF頂点サイズ
	bool fvfPSize_;
	// u_byte4宣言
	bool declUByte4_;
	// u_byte4N宣言
	bool declUByte4N_;
	// short2N宣言
	bool declShort2N_;
	// short4N宣言
	bool declShort4N_;
	// u_short2N宣言
	bool declUShort2N_;
	// u_short4N宣言
	bool declUShort4N_;
	// uDec3宣言
	bool declUDec3_;
	// dec3宣言
	bool declDec3_;
	// float16_2宣言
	bool declFloat16_2_;
	// float16_4宣言
	bool declFloat16_4_;

	//--------------------------------------------------------------------------
	// テッセレーション
	//--------------------------------------------------------------------------
	// Nパッチ最大分割レベル
	float maxNPatchTesselationLevel_;
	// ストリームオフセット
	bool streamOffset_;
	// ディスプレースメントNパッチ
	bool dmapNPatch_;
	// 適応型RTパッチ
	bool adaptiveTessRTPatch_;
	// 適応型Nパッチ
	bool adaptiveTessNPatch_;
	// テクスチャからのStretchRect
	bool canStretchRectFromTextures_;
	// プレディスプレースドNパッチ
	bool preSampledDmapNPatch_;
	// ストリームオフセット共有
	bool vertexElementsCanShareStreamOffset_;

	//--------------------------------------------------------------------------
	// シェーディング
	//--------------------------------------------------------------------------
	// カラーグーロ
	bool shadeColorGouraudRGB_;
	// スペキュラグーロ
	bool shadeSpecularGouraudRGB_;
	// アルファグーロ
	bool shadeAlphaGouraudBlend_;
	// フォググーロ
	bool shadeFogGouraud_;

	//--------------------------------------------------------------------------
	// テクスチャ
	//--------------------------------------------------------------------------
	// 最大テクスチャサイズ
	DimensionI maxTextureSize_;
	// 最大ボリュームテクスチャ辺
	u_int maxVolumeExtent_;
	// 最大テクスチャリピート数
	u_int maxTextureRepeat_;
	// 最大異方性フィルタ値
	u_int maxAnisotropy_;
	// 最大テクスチャアスペクト比
	u_int maxTextureAspectRaito_;
	// パースペクティブ補正
	bool texturePerspective_;
	// 辺は2の累乗のみ
	bool texturePow2_;
	// アルファ
	bool textureAlpha_;
	// 正方形のみ
	bool textureSquareOnly_;
	// リピートスケール無し
	bool textureRepeatNotScaledBySize_;
	// アルファパレット
	bool textureAlphaPalette_;
	// 辺は2の累乗で無くてよい
	bool textureNonPow2Conditional_;
	// 射影
	bool textureProjected_;
	// キューブマップ
	bool textureCubemap_;
	// ボリュームマップ
	bool textureVolumemap_;
	// ミップマップ
	bool textureMipmap_;
	// キューブミップマップ
	bool textureMipmapCubemap_;
	// ボリュームミップマップ
	bool textureMipmapVolumemap_;
	// キューブマップ辺は2の累乗のみ
	bool textureCubemapPow2_;
	// ボリュームマップ辺は2の累乗のみ
	bool textureVolumemapPow2_;
	// 射影バンプ環境マップ無し
	bool textureNoProjectedBumpEnvironment_;

	//--------------------------------------------------------------------------
	// テクスチャアドレス
	//--------------------------------------------------------------------------
	// ラップ
	bool textureAddressWrap_;
	// ミラー
	bool textureAddressMirror_;
	// UVのクランプ
	bool textureAddressClamp_;
	// 境界色の設定
	bool textureAddressBorder_;
	// 独立UVモード
	bool textureAddressIndependentUV_;
	// 1制限ミラー
	bool textureAddressMirrorOnce_;

	// ボリュームラップ
	bool volumeTextureAddressWrap_;
	// ボリュームミラー
	bool volumeTextureAddressMirror_;
	// ボリュームUVのクランプ
	bool volumeTextureAddressClamp_;
	// ボリューム境界色の設定
	bool volumeTextureAddressBorder_;
	// ボリューム独立UVモード
	bool volumeTextureAddressIndependentUV_;
	// ボリューム1制限ミラー
	bool volumeTextureAddressMirrorOnce_;

	//--------------------------------------------------------------------------
	// テクスチャフィルタ
	//--------------------------------------------------------------------------
	// 縮小ポイント
	bool textureFilterMinPoint_;
	// 縮小線形
	bool textureFilterMinLiner_;
	// 縮小異方性
	bool textureFilterMinAnisotropic_;
	// 縮小ピラミッド
	bool textureFilterMinPyramidalQuad_;
	// 縮小2次ガウス
	bool textureFilterMinGaussianQuad_;
	// 拡大ポイント
	bool textureFilterMagPoint_;
	// 拡大線形
	bool textureFilterMagLiner_;
	// 拡大異方性
	bool textureFilterMagAnisotropic_;
	// 拡大ピラミッド
	bool textureFilterMagPyramidalQuad_;
	// 拡大2次ガウス
	bool textureFilterMagGaussianQuad_;
	// ミップマップポイント
	bool textureFilterMipmapPoint_;
	// ミップマップ線形
	bool textureFilterMipmapLiner_;

	// キューブ縮小ポイント
	bool cubeTextureFilterMinPoint_;
	// キューブ縮小線形
	bool cubeTextureFilterMinLiner_;
	// キューブ縮小異方性
	bool cubeTextureFilterMinAnisotropic_;
	// キューブ縮小ピラミッド
	bool cubeTextureFilterMinPyramidalQuad_;
	// キューブ縮小2次ガウス
	bool cubeTextureFilterMinGaussianQuad_;
	// キューブ拡大ポイント
	bool cubeTextureFilterMagPoint_;
	// キューブ拡大線形
	bool cubeTextureFilterMagLiner_;
	// キューブ拡大異方性
	bool cubeTextureFilterMagAnisotropic_;
	// キューブ拡大ピラミッド
	bool cubeTextureFilterMagPyramidalQuad_;
	// キューブ拡大2次ガウス
	bool cubeTextureFilterMagGaussianQuad_;
	// キューブミップマップポイント
	bool cubeTextureFilterMipmapPoint_;
	// キューブミップマップ線形
	bool cubeTextureFilterMipmapLiner_;

	// ボリューム縮小ポイント
	bool volumeTextureFilterMinPoint_;
	// ボリューム縮小線形
	bool volumeTextureFilterMinLiner_;
	// ボリューム縮小異方性
	bool volumeTextureFilterMinAnisotropic_;
	// ボリューム縮小ピラミッド
	bool volumeTextureFilterMinPyramidalQuad_;
	// ボリューム縮小2次ガウス
	bool volumeTextureFilterMinGaussianQuad_;
	// ボリューム拡大ポイント
	bool volumeTextureFilterMagPoint_;
	// ボリューム拡大線形
	bool volumeTextureFilterMagLiner_;
	// ボリューム拡大異方性
	bool volumeTextureFilterMagAnisotropic_;
	// ボリューム拡大ピラミッド
	bool volumeTextureFilterMagPyramidalQuad_;
	// ボリューム拡大2次ガウス
	bool volumeTextureFilterMagGaussianQuad_;
	// ボリュームミップマップポイント
	bool volumeTextureFilterMipmapPoint_;
	// ボリュームミップマップ線形
	bool volumeTextureFilterMipmapLiner_;

	// 頂点縮小ポイント
	bool vertexTextureFilterMinPoint_;
	// 頂点縮小線形
	bool vertexTextureFilterMinLiner_;
	// 頂点縮小異方性
	bool vertexTextureFilterMinAnisotropic_;
	// 頂点縮小ピラミッド
	bool vertexTextureFilterMinPyramidalQuad_;
	// 頂点縮小2次ガウス
	bool vertexTextureFilterMinGaussianQuad_;
	// 頂点拡大ポイント
	bool vertexTextureFilterMagPoint_;
	// 頂点拡大線形
	bool vertexTextureFilterMagLiner_;
	// 頂点拡大異方性
	bool vertexTextureFilterMagAnisotropic_;
	// 頂点拡大ピラミッド
	bool vertexTextureFilterMagPyramidalQuad_;
	// 頂点拡大2次ガウス
	bool vertexTextureFilterMagGaussianQuad_;
	// 頂点ミップマップポイント
	bool vertexTextureFilterMipmapPoint_;
	// 頂点ミップマップ線形
	bool vertexTextureFilterMipmapLiner_;

	//--------------------------------------------------------------------------
	// テクスチャステージ
	//--------------------------------------------------------------------------
	// 最大テクスチャステージ数
	u_int maxTextureBlendStages_;
	// 最大マルチテクスチャ数
	u_int maxSimultaneousTextures_;
	// Disableオペレーション
	bool textureOperationDisable_;
	// SelectArg1オペレーション
	bool textureOperationSelectArg1_;
	// SelectArg2オペレーション
	bool textureOperationSelectArg2_;
	// Modulateオペレーション
	bool textureOperationModulate_;
	// Modulate2xオペレーション
	bool textureOperationModulate2x_;
	// Modulate4xオペレーション
	bool textureOperationModulate4x_;
	// Addオペレーション
	bool textureOperationAdd_;
	// AddSignedオペレーション
	bool textureOperationAddSigned_;
	// AddSigned2xオペレーション
	bool textureOperationAddSigned2x_;
	// Subtractオペレーション
	bool textureOperationSubtract_;
	// AddSmoothオペレーション
	bool textureOperationAddSmooth_;
	// BlendDiffuseAlphaオペレーション
	bool textureOperationBlendDiffuseAlpha_;
	// BlendTextureAlphaオペレーション
	bool textureOperationBlendTextureAlpha_;
	// BlendFactorAlphaオペレーション
	bool textureOperationBlendFactorAlpha_;
	// BlendTextureAlphaPMオペレーション
	bool textureOperationBlendTextureAlphaPM_;
	// BlendCurrentAlphaオペレーション
	bool textureOperationBlendCurrentAlpha_;
	// PreModulateオペレーション
	bool textureOperationPreModulate_;
	// ModulateAlphaAddColorオペレーション
	bool textureOperationModulateAlphaAddColor_;
	// ModulateColorAddAlphaオペレーション
	bool textureOperationModulateColorAddAlpha_;
	// ModulateInvAlphaAddColorオペレーション
	bool textureOperationModulateInvAlphaAddColor_;
	// ModulateInvColorAddAlphaオペレーション
	bool textureOperationModulateInvColorAddAlpha_;
	// BumpEnvMapオペレーション
	bool textureOperationBumpEnvMap_;
	// BumpEnvMapLuminanceオペレーション
	bool textureOperationBumpEnvMapLuminance_;
	// DotProduct3オペレーション
	bool textureOperationDotProduct3_;
	// MultiplyAddオペレーション
	bool textureOperationMultiplyAdd_;
	// Lerpオペレーション
	bool textureOperationLerp_;

	//--------------------------------------------------------------------------
	// 比較
	//--------------------------------------------------------------------------
	// Z比較Never
	bool zCompareNever_;
	// Z比較Less
	bool zCompareLess_;
	// Z比較Equal
	bool zCompareEqual_;
	// Z比較LessEqual
	bool zCompareLessEqual_;
	// Z比較Greater
	bool zCompareGreater_;
	// Z比較NotEqual
	bool zCompareNotEqual_;
	// Z比較GreaterEqual
	bool zCompareGreaterEqual_;
	// Z比較Always
	bool zCompareAlways_;

	// ステンシルKeep
	bool stencilKeep_;
	// ステンシルZero
	bool stencilZero_;
	// ステンシルReplace
	bool stencilReplace_;
	// ステンシルIncrSat
	bool stencilIncrSat_;
	// ステンシルDecrSat
	bool stencilDecrSat_;
	// ステンシルInvert
	bool stencilInvert_;
	// ステンシルIncr
	bool stencilIncr_;
	// ステンシルDecr
	bool stencilDecr_;
	// ステンシルTwoSided
	bool stencilTwoSided_;

	// アルファ比較Never
	bool alphaCompareNever_;
	// アルファ比較Less
	bool alphaCompareLess_;
	// アルファ比較Equal
	bool alphaCompareEqual_;
	// アルファ比較LessEqual
	bool alphaCompareLessEqual_;
	// アルファ比較Greater
	bool alphaCompareGreater_;
	// アルファ比較NotEqual
	bool alphaCompareNotEqual_;
	// アルファ比較GreaterEqual
	bool alphaCompareGreaterEqual_;
	// アルファ比較Always
	bool alphaCompareAlways_;

	//--------------------------------------------------------------------------
	// ブレンディング
	//--------------------------------------------------------------------------
	// ソースZero
	bool blendSourceZero_;
	// ソースOne
	bool blendSourceOne_;
	// ソースSrcColor
	bool blendSourceSrcColor_;
	// ソースInvSrcColor
	bool blendSourceInvSrcColor_;
	// ソースSrcAlpha
	bool blendSourceSrcAlpha_;
	// ソースInvSrcAlpha
	bool blendSourceInvSrcAlpha_;
	// ソースDestAlpha
	bool blendSourceDestAlpha_;
	// ソースInvDestAlpha
	bool blendSourceInvDestAlpha_;
	// ソースDestColor
	bool blendSourceDestColor_;
	// ソースInvDestColor
	bool blendSourceInvDestColor_;
	// ソースSrcAlphaSat
	bool blendSourceSrcAlphaSat_;
	// ソースBothSrcAlpha
	bool blendSourceBothSrcAlpha_;
	// ソースBothInvSrcAlpha
	bool blendSourceBothInvSrcAlpha_;
	// ソースBlendFactor
	bool blendSourceBlendFactor_;

	// デスティネーションZero
	bool blendDestinationZero_;
	// デスティネーションOne
	bool blendDestinationOne_;
	// デスティネーションSrcColor
	bool blendDestinationSrcColor_;
	// デスティネーションInvSrcColor
	bool blendDestinationInvSrcColor_;
	// デスティネーションSrcAlpha
	bool blendDestinationSrcAlpha_;
	// デスティネーションInvSrcAlpha
	bool blendDestinationInvSrcAlpha_;
	// デスティネーションDestAlpha
	bool blendDestinationDestAlpha_;
	// デスティネーションInvDestAlpha
	bool blendDestinationInvDestAlpha_;
	// デスティネーションDestColor
	bool blendDestinationDestColor_;
	// デスティネーションInvDestColor
	bool blendDestinationInvDestColor_;
	// デスティネーションSrcAlphaSat
	bool blendDestinationSrcAlphaSat_;
	// デスティネーションBothSrcAlpha
	bool blendDestinationBothSrcAlpha_;
	// デスティネーションBothInvSrcAlpha
	bool blendDestinationBothInvSrcAlpha_;
	// デスティネーションBlendFactor
	bool blendDestinationBlendFactor_;

	//--------------------------------------------------------------------------
	// ラスタライズ
	//--------------------------------------------------------------------------
	// アンチエイリアス拡張
	float extentsAdjust_;
	// ディザ
	bool rasterDither_;
	// Zテスト
	bool rasterZTest_;
	// 頂点フォグ
	bool rasterFogVertex_;
	// フォグテーブル
	bool rasterFogTable_;
	// ミップマップバイアス
	bool rasterMipmapLODBias_;
	// 隠れ面消去
	bool rasterZBufferLessHSR_;
	// レンジフォグ
	bool rasterFogRange_;
	// 異方性フィルタリング
	bool rasterAnisotropy_;
	// Wバッファ
	bool rasterWBuffer_;
	// Wフォグ
	bool rasterWFog_;
	// Zフォグ
	bool rasterZFog_;
	// 色パースペクティブ補正
	bool rasterColorPerspective_;
	// シザーテスト
	bool rasterScissorTest_;
	// スロープスケール深度バイアス
	bool rasterSlopeScaleDepthBias_;
	// 深度バイアス
	bool rasterDepthBias_;
	// マルチサンプル切り替え
	bool rasterMultiSampleToggle_;

	//--------------------------------------------------------------------------
	// 頂点シェーダ
	//--------------------------------------------------------------------------
	// 頂点シェーダメジャーバージョン
	u_int vertexShaderMajorVersion_;
	// 頂点シェーダマイナーバージョン
	u_int vertexShaderMinorVersion_;
	// 最大頂点シェーダ定数
	u_int maxVertexShaderConst_;
	// 最大ストリームストライド数
	u_int maxStreamStride_;
	// 最大命令実行数
	u_int maxVShaderInstructionsExecuted_;
	// 最大命令スロット数
	u_int maxVertexShader30InstructionSlots_;
	// 動的フローネストレベル
	int vertexShaderDynamicFlowControlDepth_;
	// テンポラリ数
	int vertexShaderNumTemps_;
	// 静的フローネストレベル
	int vertexShaderStaticFlowControlDepth_;
	// プレディケーション命令
	bool vertexShaderPredication_;

	//--------------------------------------------------------------------------
	// ピクセルシェーダ
	//--------------------------------------------------------------------------
	// ピクセルシェーダメジャーバージョン
	u_int pixelShaderMajorVersion_;
	// ピクセルシェーダマイナーバージョン
	u_int pixelShaderMinorVersion_;
	// ピクセルシェーダ1x最大値
	float pixelShader1xMaxValue_;
	// 最大命令実行数
	u_int maxPShaderInstructionsExecuted_;
	// 最大命令スロット数
	u_int maxPixelShader30InstructionSlots_;
	// 動的フローネストレベル
	int pixelShaderDynamicFlowControlDepth_;
	// テンポラリ数
	int pixelShaderNumTemps_;
	// 静的フローネストレベル
	int pixelShaderStaticFlowControlDepth_;
	// 命令スロット数
	int pixelShaderNumInstructionSlots_;
	// 任意の入れ替え
	bool pixelShaderArbitrarySwizzle_;
	// グラデーション命令
	bool pixelShaderGradientInstructions_;
	// プレディケーション命令
	bool pixelShaderPredication_;
	// 従属読み込み無制限
	bool pixelShaderNoDependentReadLimit_;
	// tex命令無制限
	bool pixelShaderNoTexnstructionLimit_;

};

//------------------------------------------------------------------------------
} // End of namespace Lamp
#endif // End of GRAPHICS_DEVICE_CAPACITY_H_
//------------------------------------------------------------------------------

