//------------------------------------------------------------------------------
// 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_SETTINGS_H_
#define GRAPHICS_DEVICE_SETTINGS_H_

#include <Graphics/Enumeration/GraphicsDeviceComboInformation.h>

namespace Lamp{

class GraphicsAdapterInformation;
class GraphicsDeviceInformation;

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

	//--------------------------------------------------------------------------
	/**
	 * コンストラクタ
	 */
	GraphicsDeviceSettings(){
		Assert(instance_ == NULL);
		instance_ = this;
		isWindowed_ = true;
		// ウィンドウモード
		windowedAdapterInformation_ = NULL;
		windowedDeviceInformation_ = NULL;
		windowedDeviceComboInformation_ = NULL;
		windowedDisplayMode_.Width = 0;
		windowedDisplayMode_.Height = 0;
		windowedDisplayMode_.Format = D3DFMT_UNKNOWN;
		windowedDisplayMode_.RefreshRate = 0;
		windowedDepthStencilFormat_ = D3DFMT_UNKNOWN;
		windowedMultiSampleType_ = D3DMULTISAMPLE_NONE;
		windowedMultiSampleQuality_ = 0;
		windowedVertexProcessingType_ = VertexProcessingType::software;
		windowedPresentationInterval_ = 0;
		windowSize_.set(0, 0);
		// フルスクリーンモード
		fullscreenAdapterInformation_ = NULL;
		fullscreenDeviceInformation_ = NULL;
		fullscreenDeviceComboInformation_ = NULL;
		fullscreenDisplayMode_.Width = 0;
		fullscreenDisplayMode_.Height = 0;
		fullscreenDisplayMode_.Format = D3DFMT_UNKNOWN;
		fullscreenDisplayMode_.RefreshRate = 0;
		fullscreenDepthStencilFormat_ = D3DFMT_UNKNOWN;
		fullscreenMultiSampleType_ = D3DMULTISAMPLE_NONE;
		fullscreenMultiSampleQuality_ = 0;
		fullscreenVertexProcessingType_ = VertexProcessingType::software;
		fullscreenPresentationInterval_ = 0;
	}

	/**
	 * デストラクタ
	 */
	~GraphicsDeviceSettings(){
		Assert(instance_ == this);
		instance_ = NULL;
	}
	/**
	 * プレゼンテーションパラメータの構築
	 * @param parameters [out] プレゼンテーションパラメータへのポインタ
	 * @param windowHandle ウィンドウハンドル
	 */
	virtual void buildPresentationParameters(
		D3DPRESENT_PARAMETERS* parameters, HWND windowHandle){
		// ウィンドウモードの設定
		parameters->Windowed = isWindowed();
		// ウィンドウハンドルの設定
		parameters->hDeviceWindow = windowHandle;
		// バックバッファは1枚
		parameters->BackBufferCount = 1;
		// マルチサンプルの設定
		parameters->MultiSampleType = getMultiSampleType();
		parameters->MultiSampleQuality = getMultiSampleQuality();
		// スワップ方式はドライバに任せる
		parameters->SwapEffect = D3DSWAPEFFECT_DISCARD;
		// 深度、ステンシルフォーマットが有効であれば使用する。
		bool useDepthBuffer = getDepthStencilEnabled();
		parameters->EnableAutoDepthStencil = useDepthBuffer;
		parameters->AutoDepthStencilFormat = getDepthStencilFormat();
		parameters->Flags = 0;
		if(useDepthBuffer){
			parameters->Flags |= D3DPRESENTFLAG_DISCARD_DEPTHSTENCIL;
		}
		// バックバッファの設定
		DimensionI backBufferSize = getBackBufferSize();
		parameters->BackBufferWidth = backBufferSize.width;
		parameters->BackBufferHeight = backBufferSize.height;
		parameters->BackBufferFormat = getBackBufferFormat();
		parameters->PresentationInterval = getPresentationInterval();
		if(isWindowed()){
			parameters->FullScreen_RefreshRateInHz = 0;
		}else{
			parameters->FullScreen_RefreshRateInHz =
				getDisplayMode().RefreshRate;
		}
	}

	//--------------------------------------------------------------------------
	/**
	 * ウィンドウモードの設定
	 * @param isWindowed ウィンドウモードならtrue
	 */
	virtual void setWindowed(bool isWindowed){ isWindowed_ = isWindowed; }

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

	//--------------------------------------------------------------------------
	/**
	 * バックバッファサイズの取得
	 * @return バックバッファサイズ
	 */
	virtual DimensionI getBackBufferSize(){
		DimensionI backBufferSize;
		if(isWindowed()){
			backBufferSize.set(windowSize_.width, windowSize_.height);
		}else{
			backBufferSize.set(getDisplayMode().Width, getDisplayMode().Height);
		}
		return backBufferSize;
	}

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

	//--------------------------------------------------------------------------
	/**
	 * アダプタ情報の設定
	 * @param adapterInformation アダプタ情報
	 */
	virtual void setAdapterInformation(
		GraphicsAdapterInformation* adapterInformation){
		if(isWindowed_){ windowedAdapterInformation_ = adapterInformation;; }
		else{ fullscreenAdapterInformation_ = adapterInformation; }
	}

 	/**
	 * アダプタ情報の取得
	 * @return アダプタ情報
	 */
	virtual GraphicsAdapterInformation* getAdapterInformation(){
		if(isWindowed_){ return windowedAdapterInformation_; }
		else{ return fullscreenAdapterInformation_; }
	}

	//--------------------------------------------------------------------------
	/**
	 * デバイス情報の設定
	 * @param deviceInformation デバイス情報
	 */
	virtual void setDeviceInformation(
		GraphicsDeviceInformation* deviceInformation){
		if(isWindowed_){ windowedDeviceInformation_ = deviceInformation;; }
		else{ fullscreenDeviceInformation_ = deviceInformation; }
	}

 	/**
	 * デバイス情報の取得
	 * @return デバイス情報
	 */
	virtual GraphicsDeviceInformation* getDeviceInformation(){
		if(isWindowed_){ return windowedDeviceInformation_; }
		else{ return fullscreenDeviceInformation_; }
	}

	//--------------------------------------------------------------------------
	/**
	 * デバイスコンボ情報の設定
	 * @param deviceComboInformation デバイスコンボ情報
	 */
	virtual void setDeviceComboInformation(
		GraphicsDeviceComboInformation* deviceComboInformation){
		if(isWindowed_){
			windowedDeviceComboInformation_ = deviceComboInformation;
		}else{
			fullscreenDeviceComboInformation_ = deviceComboInformation;
		}
	}

 	/**
	 * デバイスコンボ情報の取得
	 * @return デバイスコンボ情報
	 */
	virtual GraphicsDeviceComboInformation* getDeviceComboInformation(){
		if(isWindowed_){ return windowedDeviceComboInformation_; }
		else{ return fullscreenDeviceComboInformation_; }
	}

	//--------------------------------------------------------------------------
	/**
	 * ディスプレイモードの設定
	 * @param displayMode ディスプレイモード
	 */
	virtual void setDisplayMode(D3DDISPLAYMODE displayMode){
		if(isWindowed_){ windowedDisplayMode_ = displayMode; }
		else{ fullscreenDisplayMode_ = displayMode; }
	}

 	/**
	 * ディスプレイモードの取得
	 * @return ディスプレイモード
	 */
	virtual D3DDISPLAYMODE getDisplayMode(){
		if(isWindowed_){ return windowedDisplayMode_; }
		else{ return fullscreenDisplayMode_; }
	}

	//--------------------------------------------------------------------------
	/**
	 * 深度、ステンシルが有効か
	 * @return 深度、ステンシルが有効ならtrue
	 */
	virtual bool getDepthStencilEnabled(){
		return (getDepthStencilFormat() != D3DFMT_UNKNOWN);
	}

	/**
	 * 深度、ステンシルフォーマットの設定
	 * @param depthStencilFormat 深度、ステンシルフォーマット
	 */
	virtual void setDepthStencilFormat(D3DFORMAT depthStencilFormat){
		if(isWindowed_){ windowedDepthStencilFormat_ = depthStencilFormat; }
		else{ fullscreenDepthStencilFormat_ = depthStencilFormat; }
	}

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

	//--------------------------------------------------------------------------
	/**
	 * マルチサンプルタイプの設定
	 * @param multiSampleType マルチサンプルタイプ
	 */
	virtual void setMultiSampleType(D3DMULTISAMPLE_TYPE multiSampleType){
		if(isWindowed_){ windowedMultiSampleType_ = multiSampleType; }
		else{ fullscreenMultiSampleType_ = multiSampleType; }
	}

 	/**
	 * マルチサンプルタイプの取得
	 * @return マルチサンプルタイプ
	 */
	virtual D3DMULTISAMPLE_TYPE getMultiSampleType(){
		if(isWindowed_){ return windowedMultiSampleType_; }
		else{ return fullscreenMultiSampleType_; }
	}

	//--------------------------------------------------------------------------
	/**
	 * マルチサンプルクォリティの設定
	 * @param multiSampleQuality マルチサンプルクォリティ
	 */
	virtual void setMultiSampleQuality(u_int multiSampleQuality){
		if(isWindowed_){ windowedMultiSampleQuality_ = multiSampleQuality; }
		else{ fullscreenMultiSampleQuality_ = multiSampleQuality; }
	}

 	/**
	 * マルチサンプルクォリティの取得
	 * @return マルチサンプルクォリティ
	 */
	virtual u_int getMultiSampleQuality(){
		if(isWindowed_){ return windowedMultiSampleQuality_; }
		else{ return fullscreenMultiSampleQuality_; }
	}

	//--------------------------------------------------------------------------
	/**
	 * 頂点プロセスタイプの設定
	 * @param vertexProcessingType 頂点プロセスタイプ
	 */
	virtual void setVertexProcessingType(
		VertexProcessingType vertexProcessingType){
		if(isWindowed_){ windowedVertexProcessingType_ = vertexProcessingType; }
		else{ fullscreenVertexProcessingType_ = vertexProcessingType; }
	}

 	/**
	 * 頂点プロセスタイプの取得
	 * @return 頂点プロセスタイプ
	 */
	virtual VertexProcessingType getVertexProcessingType(){
		if(isWindowed_){ return windowedVertexProcessingType_; }
		else{ return fullscreenVertexProcessingType_; }
	}

	//--------------------------------------------------------------------------
	/**
	 * プレゼンテーション間隔の設定
	 * @param presentationInterval プレゼンテーション間隔
	 */
	virtual void setPresentationInterval(u_int presentationInterval){
		if(isWindowed_){ windowedPresentationInterval_ = presentationInterval; }
		else{ fullscreenPresentationInterval_ = presentationInterval; }
	}

 	/**
	 * プレゼンテーション間隔の取得
	 * @return プレゼンテーション間隔
	 */
	virtual u_int getPresentationInterval(){
		if(isWindowed_){ return windowedPresentationInterval_; }
		else{ return fullscreenPresentationInterval_; }
	}

	//--------------------------------------------------------------------------
	// ウィンドウモード
	//--------------------------------------------------------------------------
	/**
	 * ウィンドウモードアダプタ情報の設定
	 * @param adapterInformation ウィンドウモードアダプタ情報
	 */
	virtual void setWindowedAdapterInformation(
		GraphicsAdapterInformation* adapterInformation){
		windowedAdapterInformation_ = adapterInformation;
	}

 	/**
	 * ウィンドウモードアダプタ情報の取得
	 * @return ウィンドウモードアダプタ情報
	 */
	virtual GraphicsAdapterInformation* getWindowedAdapterInformation(){
		return windowedAdapterInformation_;
	}

	//--------------------------------------------------------------------------
	/**
	 * ウィンドウモードデバイス情報の設定
	 * @param deviceInformation ウィンドウモードデバイス情報
	 */
	virtual void setWindowedDeviceInformation(
		GraphicsDeviceInformation* deviceInformation){
		windowedDeviceInformation_ = deviceInformation;
	}

 	/**
	 * ウィンドウモードデバイス情報の取得
	 * @return ウィンドウモードデバイス情報
	 */
	virtual GraphicsDeviceInformation* getWindowedDeviceInformation(){
		return windowedDeviceInformation_;
	}

	//--------------------------------------------------------------------------
	/**
	 * ウィンドウモードデバイスコンボ情報の設定
	 * @param deviceComboInformation ウィンドウモードデバイスコンボ情報
	 */
	virtual void setWindowedDeviceComboInformation(
		GraphicsDeviceComboInformation* deviceComboInformation){
		windowedDeviceComboInformation_ = deviceComboInformation;
	}

 	/**
	 * ウィンドウモードデバイスコンボ情報の取得
	 * @return ウィンドウモードデバイスコンボ情報
	 */
	virtual GraphicsDeviceComboInformation* getWindowedDeviceComboInformation(){
		return windowedDeviceComboInformation_;
	}

	//--------------------------------------------------------------------------
	/**
	 * ウィンドウモードディスプレイモードの設定
	 * @param displayMode ウィンドウモードディスプレイモード
	 */
	virtual void setWindowedDisplayMode(D3DDISPLAYMODE displayMode){
		windowedDisplayMode_ = displayMode;
	}

 	/**
	 * ウィンドウモードディスプレイモードの取得
	 * @return ウィンドウモードディスプレイモード
	 */
	virtual D3DDISPLAYMODE getWindowedDisplayMode(){
		return windowedDisplayMode_;
	}

	//--------------------------------------------------------------------------
	/**
	 * ウィンドウモード深度、ステンシルフォーマットの設定
	 * @param depthStencilFormat ウィンドウモード深度、ステンシルフォーマット
	 */
	virtual void setWindowedDepthStencilFormat(D3DFORMAT depthStencilFormat){
		windowedDepthStencilFormat_ = depthStencilFormat;
	}

 	/**
	 * ウィンドウモード深度、ステンシルフォーマットの取得
	 * @return ウィンドウモード深度、ステンシルフォーマット
	 */
	virtual D3DFORMAT getWindowedDepthStencilFormat(){
		return windowedDepthStencilFormat_;
	}

	//--------------------------------------------------------------------------
	/**
	 * ウィンドウモードマルチサンプルタイプの設定
	 * @param multiSampleType ウィンドウモードマルチサンプルタイプ
	 */
	virtual void setWindowedMultiSampleType(
		D3DMULTISAMPLE_TYPE multiSampleType){
		windowedMultiSampleType_ = multiSampleType;
	}

 	/**
	 * ウィンドウモードマルチサンプルタイプの取得
	 * @return ウィンドウモードマルチサンプルタイプ
	 */
	virtual D3DMULTISAMPLE_TYPE getWindowedMultiSampleType(){
		return windowedMultiSampleType_;
	}

	//--------------------------------------------------------------------------
	/**
	 * ウィンドウモードマルチサンプルクォリティの設定
	 * @param multiSampleQuality ウィンドウモードマルチサンプルクォリティ
	 */
	virtual void setWindowedMultiSampleQuality(u_int multiSampleQuality){
		windowedMultiSampleQuality_ = multiSampleQuality;
	}

 	/**
	 * ウィンドウモードマルチサンプルクォリティの取得
	 * @return ウィンドウモードマルチサンプルクォリティ
	 */
	virtual u_int getWindowedMultiSampleQuality(){
		return windowedMultiSampleQuality_;
	}

	//--------------------------------------------------------------------------
	/**
	 * ウィンドウモード頂点プロセスタイプの設定
	 * @param vertexProcessingType ウィンドウモード頂点プロセスタイプ
	 */
	virtual void setWindowedVertexProcessingType(
		VertexProcessingType vertexProcessingType){
		windowedVertexProcessingType_ = vertexProcessingType;
	}

 	/**
	 * ウィンドウモード頂点プロセスタイプの取得
	 * @return ウィンドウモード頂点プロセスタイプ
	 */
	virtual VertexProcessingType getWindowedVertexProcessingType(){
		return windowedVertexProcessingType_;
	}

	//--------------------------------------------------------------------------
	/**
	 * ウィンドウモードプレゼンテーション間隔の設定
	 * @param presentationInterval ウィンドウモードプレゼンテーション間隔
	 */
	virtual void setWindowedPresentationInterval(u_int presentationInterval){
		windowedPresentationInterval_ = presentationInterval;
	}

 	/**
	 * ウィンドウモードプレゼンテーション間隔の取得
	 * @return ウィンドウモードプレゼンテーション間隔
	 */
	virtual u_int getWindowedPresentationInterval(){
		return windowedPresentationInterval_;
	}

	//--------------------------------------------------------------------------
	/**
	 * ウィンドウサイズの設定
	 * @param size ウィンドウサイズ
	 */
	virtual void setWindowSize(DimensionI size){ windowSize_ = size; }

 	/**
	 * ウィンドウサイズの取得
	 * @return ウィンドウサイズ
	 */
	virtual const DimensionI& getWindowSize(){ return windowSize_; }

	//--------------------------------------------------------------------------
	// フルスクリーンモード
	//--------------------------------------------------------------------------
	/**
	 * フルスクリーンモードアダプタ情報の設定
	 * @param adapterInformation フルスクリーンモードアダプタ情報
	 */
	virtual void setFullscreenAdapterInformation(
		GraphicsAdapterInformation* adapterInformation){
		fullscreenAdapterInformation_ = adapterInformation;
	}

 	/**
	 * フルスクリーンモードアダプタ情報の取得
	 * @return フルスクリーンモードアダプタ情報
	 */
	virtual GraphicsAdapterInformation* getFullscreenAdapterInformation(){
		return fullscreenAdapterInformation_;
	}

	//--------------------------------------------------------------------------
	/**
	 * フルスクリーンモードデバイス情報の設定
	 * @param deviceInformation フルスクリーンモードデバイス情報
	 */
	virtual void setFullscreenDeviceInformation(
		GraphicsDeviceInformation* deviceInformation){
		fullscreenDeviceInformation_ = deviceInformation;
	}

 	/**
	 * フルスクリーンモードデバイス情報の取得
	 * @return フルスクリーンモードデバイス情報
	 */
	virtual GraphicsDeviceInformation* getFullscreenDeviceInformation(){
		return fullscreenDeviceInformation_;
	}

	//--------------------------------------------------------------------------
	/**
	 * フルスクリーンモードデバイスコンボ情報の設定
	 * @param deviceComboInformation フルスクリーンモードデバイスコンボ情報
	 */
	virtual void setFullscreenDeviceComboInformation(
		GraphicsDeviceComboInformation* deviceComboInformation){
		fullscreenDeviceComboInformation_ = deviceComboInformation;
	}

 	/**
	 * フルスクリーンモードデバイスコンボ情報の取得
	 * @return フルスクリーンモードデバイスコンボ情報
	 */
	virtual GraphicsDeviceComboInformation*
		getFullscreenDeviceComboInformation(){
		return fullscreenDeviceComboInformation_;
	}

	//--------------------------------------------------------------------------
	/**
	 * フルスクリーンモードディスプレイモードの設定
	 * @param displayMode フルスクリーンモードディスプレイモード
	 */
	virtual void setFullscreenDisplayMode(D3DDISPLAYMODE displayMode){
		fullscreenDisplayMode_ = displayMode;
	}

 	/**
	 * フルスクリーンモードディスプレイモードの取得
	 * @return フルスクリーンモードディスプレイモード
	 */
	virtual D3DDISPLAYMODE getFullscreenDisplayMode(){
		return fullscreenDisplayMode_;
	}

	//--------------------------------------------------------------------------
	/**
	 * フルスクリーンモード深度、ステンシルフォーマットの設定
	 * @param depthStencilFormat フルスクリーンモード深度、ステンシルフォーマット
	 */
	virtual void setFullscreenDepthStencilFormat(D3DFORMAT depthStencilFormat){
		fullscreenDepthStencilFormat_ = depthStencilFormat;
	}

 	/**
	 * フルスクリーンモード深度、ステンシルフォーマットの取得
	 * @return フルスクリーンモード深度、ステンシルフォーマット
	 */
	virtual D3DFORMAT getFullscreenDepthStencilFormat(){
		return fullscreenDepthStencilFormat_;
	}

	//--------------------------------------------------------------------------
	/**
	 * フルスクリーンモードマルチサンプルタイプの設定
	 * @param multiSampleType フルスクリーンモードマルチサンプルタイプ
	 */
	virtual void setFullscreenMultiSampleType(
		D3DMULTISAMPLE_TYPE multiSampleType){
		fullscreenMultiSampleType_ = multiSampleType;
	}

 	/**
	 * フルスクリーンモードマルチサンプルタイプの取得
	 * @return フルスクリーンモードマルチサンプルタイプ
	 */
	virtual D3DMULTISAMPLE_TYPE getFullscreenMultiSampleType(){
		return fullscreenMultiSampleType_;
	}

	//--------------------------------------------------------------------------
	/**
	 * フルスクリーンモードマルチサンプルクォリティの設定
	 * @param multiSampleQuality フルスクリーンモードマルチサンプルクォリティ
	 */
	virtual void setFullscreenMultiSampleQuality(u_int multiSampleQuality){
		fullscreenMultiSampleQuality_ = multiSampleQuality;
	}

 	/**
	 * フルスクリーンモードマルチサンプルクォリティの取得
	 * @return フルスクリーンモードマルチサンプルクォリティ
	 */
	virtual u_int getFullscreenMultiSampleQuality(){
		return fullscreenMultiSampleQuality_;
	}

	//--------------------------------------------------------------------------
	/**
	 * フルスクリーンモード頂点プロセスタイプの設定
	 * @param vertexProcessingType フルスクリーンモード頂点プロセスタイプ
	 */
	virtual void setFullscreenVertexProcessingType(
		VertexProcessingType vertexProcessingType){
		fullscreenVertexProcessingType_ = vertexProcessingType;
	}

 	/**
	 * フルスクリーンモード頂点プロセスタイプの取得
	 * @return フルスクリーンモード頂点プロセスタイプ
	 */
	virtual VertexProcessingType getFullscreenVertexProcessingType(){
		return fullscreenVertexProcessingType_;
	}

	//--------------------------------------------------------------------------
	/**
	 * フルスクリーンモードプレゼンテーション間隔の設定
	 * @param presentationInterval フルスクリーンモードプレゼンテーション間隔
	 */
	virtual void setFullscreenPresentationInterval(u_int presentationInterval){
		fullscreenPresentationInterval_ = presentationInterval;
	}

 	/**
	 * フルスクリーンモードプレゼンテーション間隔の取得
	 * @return フルスクリーンモードプレゼンテーション間隔
	 */
	virtual u_int getFullscreenPresentationInterval(){
		return fullscreenPresentationInterval_;
	}

private:
	// ウィンドウモードか
	bool isWindowed_;

	//--------------------------------------------------------------------------
	// ウィンドウモード
	//--------------------------------------------------------------------------

	// アダプタ情報
	GraphicsAdapterInformation* windowedAdapterInformation_;
	// デバイス情報
	GraphicsDeviceInformation* windowedDeviceInformation_;
	// デバイスコンボ情報
	GraphicsDeviceComboInformation* windowedDeviceComboInformation_;
	// ディスプレイモード
	D3DDISPLAYMODE windowedDisplayMode_;
	// 深度、ステンシルフォーマット
	D3DFORMAT windowedDepthStencilFormat_;
	// マルチサンプルタイプ
	D3DMULTISAMPLE_TYPE windowedMultiSampleType_;
	// マルチサンプルクォリティ
	u_int windowedMultiSampleQuality_;
	// 頂点プロセスタイプ
	VertexProcessingType windowedVertexProcessingType_;
	// プレゼンテーション間隔
	u_int windowedPresentationInterval_;
	// ウィンドウサイズ
	DimensionI windowSize_;

	//--------------------------------------------------------------------------
	// フルスクリーンモード
	//--------------------------------------------------------------------------

	// アダプタ情報
	GraphicsAdapterInformation* fullscreenAdapterInformation_;
	// デバイス情報
	GraphicsDeviceInformation* fullscreenDeviceInformation_;
	// デバイスコンボ情報
	GraphicsDeviceComboInformation* fullscreenDeviceComboInformation_;
	// ディスプレイモード
	D3DDISPLAYMODE fullscreenDisplayMode_;
	// 深度、ステンシルフォーマット
	D3DFORMAT fullscreenDepthStencilFormat_;
	// マルチサンプルタイプ
	D3DMULTISAMPLE_TYPE fullscreenMultiSampleType_;
	// マルチサンプルクォリティ
	u_int fullscreenMultiSampleQuality_;
	// 頂点プロセスタイプ
	VertexProcessingType fullscreenVertexProcessingType_;
	// プレゼンテーション間隔
	u_int fullscreenPresentationInterval_;

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

};

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