"BasicEffect" lemputės

suvestinė

Manipuliuokite parametrais, susijusiais su šviesiąja "BasicEffect" dalimi, kad pamatytumėte, kaip modelis rodomas.

Darbo aplinka

Būtinosios sąlygos

Darbo aplinka

Kaip dirbti su pavyzdžiu

medžiaga

šviesa

Šviesos naudojamos medžiagos šešėliams pavaizduoti. XNA šviesos nėra nustatytos kaip vienas iš aplinkos nustatymų, bet yra nustatytos individualiems efektams.

"BasicEffect" yra trys lygiagretūs šviesos šaltiniai, o kiekviena šviesa turi šiuos parametrus:

Taip pat yra savybių, kurios yra bendros atskiroms šviesoms.

Šviesos pokyčio vaizdas

Žemiau esančiame paveikslėlyje parodytos skirtingos šviesų vertės. Pavyzdyje įjungtos visos trys lemputės, tačiau žemiau esančiame paveikslėlyje jai rodyti naudojama tik viena lemputė.

Pradinė būsena

Tai yra būsena iškart po to, kai įkeliami pavyzdinio modelio duomenys.

DiffuseColor modifikacija

Šviesos "DiffuseColor" keitimas. Kadangi raudona ir mėlyna yra nustatytos į 0, o žalia – į 1, paryškinama tik žalia modelio dalis. (Raudona ir mėlyna spalvos taip pat yra silpnai matomos, tačiau taip yra dėl aplinkos šviesos.)

SpecularColor pokytis

Atspindėtos šviesos spalvos keitimas. Kadangi nustatyta tik žalia spalva, atspindinčios dalies spalva yra tik žalias elementas.

Krypties keitimas

Galite pakeisti šviesos kryptį pakeisdami kryptį. Paprastai naudojama tik orientacija, todėl vektorius normalizuojamas.

AmbientLightColor pokytis

Raudoni ir mėlyni aplinkos žibintai yra maksimaliai padidinti, o žalia - 0. Jei pažvelgsite į sritis, kuriose šviesa nešviečia, galite aiškiai matyti skirtumą tarp žalios, raudonos ir mėlynos spalvos atspalvių.

PreferPerPixelLighting modifikacija

Nustatykite PreferPerPixelLighting į True (teisinga), kad būtų galima apskaičiuoti apšvietimą pagal pikselius. Diagramoje sunku įžiūrėti, tačiau viršūnių lygio apšvietimo atveju daugiakampių ribos yra kažkaip matomos, tačiau pikselių apšvietimo atveju galima išreikšti labai lygius šešėlius.

Beje, negalite naudoti ypatybės PreferPerPixelLighting, jei nepalaikote pixel shader 2.0. Be to, jei naudojate kelias šviesas, tai gali atrodyti keistai.

Apšvietimas vienoje viršūnėjePer-pixel	apšvietimas

Žibintų parametrų klasės apibrėžimai

Kadangi "BasicEffect" gali turėti kelias šviesas, sukūrėme klasę šviesos parametrams nustatyti. Parametrai yra tokie patys, kaip ir tie, kuriuos galima nustatyti "BasicEffect" šviesai ("BasicDirectionalLight").

/// <summary>
/// ライトパラメータ
/// </summary>
public class LightParameter
{
    /// <summary>
    /// ライト有効フラグ
    /// </summary>
    public bool Enabled;

    /// <summary>
    /// ディフューズカラー
    /// </summary>
    public Vector3 DiffuseColor;

    /// <summary>
    /// スペキュラーカラー
    /// </summary>
    public Vector3 SpecularColor;

    /// <summary>
    /// ライトの方向
    /// </summary>
    public Vector3 Direction;
}

laukas

Apibrėžia parametrus, reikalingus šviesai nustatyti. Kadangi žibintams galite nustatyti tris žibintus, masyvo elementų skaičius taip pat yra trys. Kiti laukai naudojami meniu operacijoms, simbolių rodymui ir kt., todėl žiūrėkite visą kodą.

/// <summary>
/// 選択しているライトのインデックス
/// </summary>
private int selectedLightIndex = 0;

/// <summary>
/// ライトのパラメータ
/// </summary>
private LightParameter[] lightParameters = new LightParameter[]
    {
        new LightParameter(),
        new LightParameter(),
        new LightParameter()
    };

/// <summary>
/// アンビエントカラー
/// </summary>
private Vector3 ambientLightColor = Vector3.Zero;

/// <summary>
/// ピクセル単位のライティング
/// </summary>
private bool isPreferPerPixelLighting = false;

Numatytasis rašymo įgijimas

"BasicEffect.EnableDefaultLighting" metodas nustato "XNA Framework" nurodytus šviesos parametrus. Mes gauname šią vertę, kad vieną kartą ją išlaikytume lauke. (Pavyzdyje tai yra įsigijimo kelis kartus forma, tačiau ji yra supaprastinta, nes ji bus ilga, jei parašysite kodą, kad jį įsigytumėte atskirai.)

// ライトとビュー、プロジェクションはあらかじめ設定しておく
foreach (ModelMesh mesh in this.model.Meshes)
{
    foreach (BasicEffect effect in mesh.Effects)
    {
        // デフォルトのライト適用
        effect.EnableDefaultLighting();

        // ビューマトリックスをあらかじめ設定 ((0, 0, 8) から原点を見る)
        effect.View = Matrix.CreateLookAt(
            new Vector3(0.0f, 0.0f, 8.0f),
            Vector3.Zero,
            Vector3.Up
        );

        // プロジェクションマトリックスをあらかじめ設定
        effect.Projection = Matrix.CreatePerspectiveFieldOfView(
            MathHelper.ToRadians(45.0f),
            (float)this.GraphicsDevice.Viewport.Width /
                (float)this.GraphicsDevice.Viewport.Height,
            1.0f,
            100.0f
        );

        // デフォルトのパラメータを受け取る
        this.lightParameters[0].Enabled = effect.DirectionalLight0.Enabled;
        this.lightParameters[0].DiffuseColor = effect.DirectionalLight0.DiffuseColor;
        this.lightParameters[0].SpecularColor = effect.DirectionalLight0.SpecularColor;
        this.lightParameters[0].Direction = effect.DirectionalLight0.Direction;

        this.lightParameters[1].Enabled = effect.DirectionalLight1.Enabled;
        this.lightParameters[1].DiffuseColor = effect.DirectionalLight1.DiffuseColor;
        this.lightParameters[1].SpecularColor = effect.DirectionalLight1.SpecularColor;
        this.lightParameters[1].Direction = effect.DirectionalLight1.Direction;

        this.lightParameters[2].Enabled = effect.DirectionalLight2.Enabled;
        this.lightParameters[2].DiffuseColor = effect.DirectionalLight2.DiffuseColor;
        this.lightParameters[2].SpecularColor = effect.DirectionalLight2.SpecularColor;
        this.lightParameters[2].Direction = effect.DirectionalLight2.Direction;

        // アンビエントカラー
        this.ambientLightColor = effect.AmbientLightColor;

        // ピクセル単位のライティング
        this.isPreferPerPixelLighting = effect.PreferPerPixelLighting;
    }
}

Šviesų nustatymas

Aš nustatau šviesą modelio "BasicEffect". Vertė tiesiog nustatoma į "BasicEffect" šviesos parametrą. Norėdami sužinoti šviesos parametrų keitimo operacijos kodą, žiūrėkite visą kodą atskirai.

foreach (ModelMesh mesh in this.model.Meshes)
{
    foreach (BasicEffect effect in mesh.Effects)
    {
        for (int i = 0; i < this.lightParameters.Length; i++)
        {
            // ライトを取得
            BasicDirectionalLight light = null;

            switch (i)
            {
                case 0:
                    light = effect.DirectionalLight0;
                    break;
                case 1:
                    light = effect.DirectionalLight1;
                    break;
                case 2:
                    light = effect.DirectionalLight2;
                    break;
            }

            // ライト有効フラグ
            light.Enabled = this.lightParameters[i].Enabled;

            // ライトのディフーズカラー
            light.DiffuseColor = this.lightParameters[i].DiffuseColor;

            // ライトのスペキュラーカラー
            light.SpecularColor = this.lightParameters[i].SpecularColor;

            // ライトの方向
            light.Direction = this.lightParameters[i].Direction;
        }

        // アンビエントカラー
        effect.AmbientLightColor = this.ambientLightColor;

        // ピクセル単位のライティング
        effect.PreferPerPixelLighting = this.isPreferPerPixelLighting;

    }
}

BasicEffect.DirectionalLight0 nuosavybė

BasicEffect.DirectionalLight1 nuosavybė

BasicEffect.DirectionalLight2 nuosavybė

BasicEffect.AmbientLightColor nuosavybė

BasicEffect.PreferPerPixelLighting nuosavybė

BasicDirectionalLight.Enabled nuosavybė

BasicDirectionalLight.DiffuseColor nuosavybė

BasicDirectionalLight.SpecularColor nuosavybė

BasicDirectionalLight.Direction nuosavybė

Visi kodai

using System;
using System.Collections.Generic;
using System.Linq;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Audio;
using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework.GamerServices;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Input;
using Microsoft.Xna.Framework.Media;
#if WINDOWS_PHONE
using Microsoft.Xna.Framework.Input.Touch;
#endif

namespace BasicEffectLight
{
    /// <summary>
    /// ゲームメインクラス
    /// </summary>
    public class GameMain : Microsoft.Xna.Framework.Game
    {
        /// <summary>
        /// ライトパラメータ
        /// </summary>
        public class LightParameter
        {
            /// <summary>
            /// ライト有効フラグ
            /// </summary>
            public bool Enabled;

            /// <summary>
            /// ディフューズカラー
            /// </summary>
            public Vector3 DiffuseColor;

            /// <summary>
            /// スペキュラーカラー
            /// </summary>
            public Vector3 SpecularColor;

            /// <summary>
            /// ライトの方向
            /// </summary>
            public Vector3 Direction;
        }

        /// <summary>
        /// グラフィックデバイス管理クラス
        /// </summary>
        private GraphicsDeviceManager graphics = null;

        /// <summary>
        /// スプライトのバッチ化クラス
        /// </summary>
        private SpriteBatch spriteBatch = null;

        /// <summary>
        /// スプライトでテキストを描画するためのフォント
        /// </summary>
        private SpriteFont font = null;

        /// <summary>
        /// 直前のキーボード入力の状態
        /// </summary>
        private KeyboardState oldKeyboardState = new KeyboardState();

        /// <summary>
        /// 直前のマウスの状態
        /// </summary>
        private MouseState oldMouseState = new MouseState();

        /// <summary>
        /// 直前のゲームパッド入力の状態
        /// </summary>
        private GamePadState oldGamePadState = new GamePadState();

        /// <summary>
        /// モデル
        /// </summary>
        private Model model = null;

        /// <summary>
        /// 選択しているメニューのインデックス
        /// </summary>
        private int selectedMenuIndex = 0;

        /// <summary>
        /// 選択しているライトのインデックス
        /// </summary>
        private int selectedLightIndex = 0;

        /// <summary>
        /// ライトのパラメータ
        /// </summary>
        private LightParameter[] lightParameters = new LightParameter[]
            {
                new LightParameter(),
                new LightParameter(),
                new LightParameter()
            };

        /// <summary>
        /// アンビエントカラー
        /// </summary>
        private Vector3 ambientLightColor = Vector3.Zero;

        /// <summary>
        /// ピクセル単位のライティング
        /// </summary>
        private bool isPreferPerPixelLighting = false;

        /// <summary>
        /// パラメータの最大数
        /// </summary>
        private static int MaxParameterCount = 15;

        /// <summary>
        /// メニューリスト
        /// </summary>
        private static string[] MenuNameList = new string[]
            {
                "LightIndex",
                "Light Enable",
                "DiffuseColor (Red)",
                "DiffuseColor (Green)",
                "DiffuseColor (Blue)",
                "SpecularColor (Red)",
                "SpecularColor (Green)",
                "SpecularColor (Blue)",
                "Direction X",
                "Direction Y",
                "Direction Z",
                "AmbientLightColor (Red)",
                "AmbientLightColor (Green)",
                "AmbientLightColor (Blue)",
                "PreferPerPixelLighting",
            };

        /// <summary>
        /// パラメータテキストリスト
        /// </summary>
        private string[] parameters = new string[MaxParameterCount];


        /// <summary>
        /// GameMain コンストラクタ
        /// </summary>
        public GameMain()
        {
            // グラフィックデバイス管理クラスの作成
            this.graphics = new GraphicsDeviceManager(this);

            // ゲームコンテンツのルートディレクトリを設定
            this.Content.RootDirectory = "Content";

#if WINDOWS_PHONE
            // Windows Phone のデフォルトのフレームレートは 30 FPS
            this.TargetElapsedTime = TimeSpan.FromTicks(333333);

            // バックバッファサイズの設定
            this.graphics.PreferredBackBufferWidth = 480;
            this.graphics.PreferredBackBufferHeight = 800;

            // フルスクリーン表示
            this.graphics.IsFullScreen = true;
#endif

            // ウインドウ上でマウスのポインタを表示するようにする
            this.IsMouseVisible = true;
        }

        /// <summary>
        /// ゲームが始まる前の初期化処理を行うメソッド
        /// グラフィック以外のデータの読み込み、コンポーネントの初期化を行う
        /// </summary>
        protected override void Initialize()
        {
            // TODO: ここに初期化ロジックを書いてください

            // コンポーネントの初期化などを行います
            base.Initialize();
        }

        /// <summary>
        /// ゲームが始まるときに一回だけ呼ばれ
        /// すべてのゲームコンテンツを読み込みます
        /// </summary>
        protected override void LoadContent()
        {
            // テクスチャーを描画するためのスプライトバッチクラスを作成します
            this.spriteBatch = new SpriteBatch(this.GraphicsDevice);

            // フォントをコンテンツパイプラインから読み込む
            this.font = this.Content.Load<SpriteFont>("Font");

            // モデルを作成
            this.model = this.Content.Load<Model>("Model");

            // ライトとビュー、プロジェクションはあらかじめ設定しておく
            foreach (ModelMesh mesh in this.model.Meshes)
            {
                foreach (BasicEffect effect in mesh.Effects)
                {
                    // デフォルトのライト適用
                    effect.EnableDefaultLighting();

                    // ビューマトリックスをあらかじめ設定 ((0, 0, 8) から原点を見る)
                    effect.View = Matrix.CreateLookAt(
                        new Vector3(0.0f, 0.0f, 8.0f),
                        Vector3.Zero,
                        Vector3.Up
                    );

                    // プロジェクションマトリックスをあらかじめ設定
                    effect.Projection = Matrix.CreatePerspectiveFieldOfView(
                        MathHelper.ToRadians(45.0f),
                        (float)this.GraphicsDevice.Viewport.Width /
                            (float)this.GraphicsDevice.Viewport.Height,
                        1.0f,
                        100.0f
                    );

                    // デフォルトのパラメータを受け取る
                    this.lightParameters[0].Enabled = effect.DirectionalLight0.Enabled;
                    this.lightParameters[0].DiffuseColor = effect.DirectionalLight0.DiffuseColor;
                    this.lightParameters[0].SpecularColor = effect.DirectionalLight0.SpecularColor;
                    this.lightParameters[0].Direction = effect.DirectionalLight0.Direction;

                    this.lightParameters[1].Enabled = effect.DirectionalLight1.Enabled;
                    this.lightParameters[1].DiffuseColor = effect.DirectionalLight1.DiffuseColor;
                    this.lightParameters[1].SpecularColor = effect.DirectionalLight1.SpecularColor;
                    this.lightParameters[1].Direction = effect.DirectionalLight1.Direction;

                    this.lightParameters[2].Enabled = effect.DirectionalLight2.Enabled;
                    this.lightParameters[2].DiffuseColor = effect.DirectionalLight2.DiffuseColor;
                    this.lightParameters[2].SpecularColor = effect.DirectionalLight2.SpecularColor;
                    this.lightParameters[2].Direction = effect.DirectionalLight2.Direction;

                    // アンビエントカラー
                    this.ambientLightColor = effect.AmbientLightColor;

                    // ピクセル単位のライティング
                    this.isPreferPerPixelLighting = effect.PreferPerPixelLighting;
                }
            }
        }

        /// <summary>
        /// ゲームが終了するときに一回だけ呼ばれ
        /// すべてのゲームコンテンツをアンロードします
        /// </summary>
        protected override void UnloadContent()
        {
            // TODO: ContentManager で管理されていないコンテンツを
            //       ここでアンロードしてください
        }

        /// <summary>
        /// 描画以外のデータ更新等の処理を行うメソッド
        /// 主に入力処理、衝突判定などの物理計算、オーディオの再生など
        /// </summary>
        /// <param name="gameTime">このメソッドが呼ばれたときのゲーム時間</param>
        protected override void Update(GameTime gameTime)
        {
            // 入力デバイスの状態取得
            KeyboardState keyboardState = Keyboard.GetState();
            MouseState mouseState = Mouse.GetState();
            GamePadState gamePadState = GamePad.GetState(PlayerIndex.One);

            // Xbox 360 コントローラ、Windows Phone の BACK ボタンを押したときに
            // ゲームを終了させます
            if (gamePadState.Buttons.Back == ButtonState.Pressed)
            {
                this.Exit();
            }

            // メニューの選択
            if ((keyboardState.IsKeyDown(Keys.Up) && this.oldKeyboardState.IsKeyUp(Keys.Up)) ||
                (gamePadState.ThumbSticks.Left.Y >= 0.5f &&
                    this.oldGamePadState.ThumbSticks.Left.Y < 0.5f))
            {
                // 選択メニューをひとつ上に移動
                this.selectedMenuIndex =
                    (this.selectedMenuIndex + this.parameters.Length - 1) % this.parameters.Length;
            }
            if ((keyboardState.IsKeyDown(Keys.Down) && this.oldKeyboardState.IsKeyUp(Keys.Down)) ||
                (gamePadState.ThumbSticks.Left.Y <= -0.5f &&
                    this.oldGamePadState.ThumbSticks.Left.Y > -0.5f) ||
                (this.oldMouseState.LeftButton == ButtonState.Pressed &&
                 mouseState.LeftButton == ButtonState.Released))
            {
                // 選択メニューをひとつ下に移動
                this.selectedMenuIndex =
                    (this.selectedMenuIndex + this.parameters.Length + 1) % this.parameters.Length;
            }

            // 各マテリアルの値を操作
            float moveValue = 0.0f;
            if (keyboardState.IsKeyDown(Keys.Left))
            {
                moveValue -= (float)gameTime.ElapsedGameTime.TotalSeconds;
            }
            if (keyboardState.IsKeyDown(Keys.Right))
            {
                moveValue += (float)gameTime.ElapsedGameTime.TotalSeconds;
            }
            if (mouseState.LeftButton == ButtonState.Pressed)
            {
                moveValue += (mouseState.X - this.oldMouseState.X) * 0.005f;
            }
            if (gamePadState.IsConnected)
            {
                moveValue += gamePadState.ThumbSticks.Left.X *
                             (float)gameTime.ElapsedGameTime.TotalSeconds;
            }

            if (moveValue != 0.0f)
            {
                LightParameter selectedLight = this.lightParameters[this.selectedLightIndex];

                switch (this.selectedMenuIndex)
                {
                    case 0:
                        // ライトのインデックス
                        if ((keyboardState.IsKeyDown(Keys.Left) &&
                                this.oldKeyboardState.IsKeyUp(Keys.Left)) ||
                            (mouseState.LeftButton == ButtonState.Pressed &&
                                (mouseState.X - this.oldMouseState.X) >= 5) ||
                            (gamePadState.ThumbSticks.Left.X >= 0.5f &&
                                this.oldGamePadState.ThumbSticks.Left.X < 0.5f))
                        {
                            // ライトのインデックスをひとつ減らす
                            this.selectedLightIndex =
                                (this.selectedLightIndex + this.lightParameters.Length - 1) %
                                    this.lightParameters.Length;
                        }
                        if ((keyboardState.IsKeyDown(Keys.Right) &&
                                this.oldKeyboardState.IsKeyUp(Keys.Right)) ||
                            (mouseState.LeftButton == ButtonState.Pressed &&
                                (mouseState.X - this.oldMouseState.X) <= -5) ||
                            (gamePadState.ThumbSticks.Left.X <= -0.5f &&
                                this.oldGamePadState.ThumbSticks.Left.X > -0.5f))
                        {
                            // ライトのインデックスをひとつ増やす
                            this.selectedLightIndex =
                                (this.selectedLightIndex + this.lightParameters.Length + 1) %
                                    this.lightParameters.Length;
                        }
                        if (mouseState.LeftButton == ButtonState.Pressed)
                        {
                            this.selectedLightIndex = (int)(
                                MathHelper.Clamp((float)mouseState.X / this.GraphicsDevice.Viewport.Width * 3, 0, 2));
                        }
                        break;
                    case 1:
                        // ライト有効フラグ
                        selectedLight.Enabled = (moveValue > 0.0f);
                        break;
                    case 2:
                        // ライトのディフーズカラー(赤)
                        Vector3 diffuseX = selectedLight.DiffuseColor;
                        diffuseX.X = MathHelper.Clamp(diffuseX.X + moveValue, 0.0f, 1.0f);
                        selectedLight.DiffuseColor = diffuseX;
                        break;
                    case 3:
                        // ライトのディフーズカラー(緑)
                        Vector3 diffuseY = selectedLight.DiffuseColor;
                        diffuseY.Y = MathHelper.Clamp(diffuseY.Y + moveValue, 0.0f, 1.0f);
                        selectedLight.DiffuseColor = diffuseY;
                        break;
                    case 4:
                        // ライトのディフーズカラー(青)
                        Vector3 diffuseZ = selectedLight.DiffuseColor;
                        diffuseZ.Z = MathHelper.Clamp(diffuseZ.Z + moveValue, 0.0f, 1.0f);
                        selectedLight.DiffuseColor = diffuseZ;
                        break;
                    case 5:
                        // ライトのスペキュラーカラー(赤)
                        Vector3 specularX = selectedLight.SpecularColor;
                        specularX.X = MathHelper.Clamp(specularX.X + moveValue, 0.0f, 1.0f);
                        selectedLight.SpecularColor = specularX;
                        break;
                    case 6:
                        // ライトのスペキュラーカラー(緑)
                        Vector3 specularY = selectedLight.SpecularColor;
                        specularY.Y = MathHelper.Clamp(specularY.Y + moveValue, 0.0f, 1.0f);
                        selectedLight.SpecularColor = specularY;
                        break;
                    case 7:
                        // ライトのスペキュラーカラー(青)
                        Vector3 specularZ = selectedLight.SpecularColor;
                        specularZ.Z = MathHelper.Clamp(specularZ.Z + moveValue, 0.0f, 1.0f);
                        selectedLight.SpecularColor = specularZ;
                        break;
                    case 8:
                        // ライトの方向X
                        Vector3 directionX = selectedLight.Direction;
                        directionX.X += moveValue;
                        selectedLight.Direction = directionX;
                        break;
                    case 9:
                        // ライトの方向Y
                        Vector3 directionY = selectedLight.Direction;
                        directionY.Y += moveValue;
                        selectedLight.Direction = directionY;
                        break;
                    case 10:
                        // ライトの方向Z
                        Vector3 directionZ = selectedLight.Direction;
                        directionZ.Z += moveValue;
                        selectedLight.Direction = directionZ;
                        break;
                    case 11:
                        // アンビエントカラー(赤)
                        this.ambientLightColor.X =
                            MathHelper.Clamp(this.ambientLightColor.X + moveValue, 0.0f, 1.0f);
                        break;
                    case 12:
                        // アンビエントカラー(緑)
                        this.ambientLightColor.Y =
                            MathHelper.Clamp(this.ambientLightColor.Y + moveValue, 0.0f, 1.0f);
                        break;
                    case 13:
                        // アンビエントカラー(青)
                        this.ambientLightColor.Z =
                            MathHelper.Clamp(this.ambientLightColor.Z + moveValue, 0.0f, 1.0f);
                        break;
                    case 14:
                        // ピクセル単位のライティング
                        this.isPreferPerPixelLighting = (moveValue > 0.0f);
                        break;
                }
            }

            // ライトを設定
            foreach (ModelMesh mesh in this.model.Meshes)
            {
                foreach (BasicEffect effect in mesh.Effects)
                {
                    for (int i = 0; i < this.lightParameters.Length; i++)
                    {
                        // ライトを取得
                        DirectionalLight light = null;

                        switch (i)
                        {
                            case 0:
                                light = effect.DirectionalLight0;
                                break;
                            case 1:
                                light = effect.DirectionalLight1;
                                break;
                            case 2:
                                light = effect.DirectionalLight2;
                                break;
                        }

                        // ライト有効フラグ
                        light.Enabled = this.lightParameters[i].Enabled;

                        // ライトのディフーズカラー
                        light.DiffuseColor = this.lightParameters[i].DiffuseColor;

                        // ライトのスペキュラーカラー
                        light.SpecularColor = this.lightParameters[i].SpecularColor;

                        // ライトの方向
                        light.Direction = this.lightParameters[i].Direction;
                    }

                    // アンビエントカラー
                    effect.AmbientLightColor = this.ambientLightColor;

                    // ピクセル単位のライティング
                    effect.PreferPerPixelLighting = this.isPreferPerPixelLighting;

                }
            }

            // 入力情報を記憶
            this.oldKeyboardState = keyboardState;
            this.oldMouseState = mouseState;
            this.oldGamePadState = gamePadState;

            // 登録された GameComponent を更新する
            base.Update(gameTime);
        }

        /// <summary>
        /// 描画処理を行うメソッド
        /// </summary>
        /// <param name="gameTime">このメソッドが呼ばれたときのゲーム時間</param>
        protected override void Draw(GameTime gameTime)
        {
            // 画面を指定した色でクリアします
            this.GraphicsDevice.Clear(Color.CornflowerBlue);

            // 深度バッファを有効にする
            this.GraphicsDevice.DepthStencilState = DepthStencilState.Default;

            // モデルを描画
            foreach (ModelMesh mesh in this.model.Meshes)
            {
#if WINDOWS_PHONE
                foreach (BasicEffect effect in mesh.Effects)
                {
                    effect.World = Matrix.CreateRotationZ(-MathHelper.PiOver2);
                }
#endif

                mesh.Draw();
            }

            // スプライトの描画準備
            this.spriteBatch.Begin();

            // 操作
            this.spriteBatch.DrawString(this.font,
                "Up, Down : Select Menu",
                new Vector2(20.0f, 20.0f), Color.White);
            this.spriteBatch.DrawString(this.font,
                "Left, right : Change Value",
                new Vector2(20.0f, 45.0f), Color.White);
            this.spriteBatch.DrawString(this.font,
                "MouseClick & Drag :",
                new Vector2(20.0f, 70.0f), Color.White);
            this.spriteBatch.DrawString(this.font,
                "    Select Menu & Change Value",
                new Vector2(20.0f, 95.0f), Color.White);

            // 各メニュー //
            for (int i = 0; i < MenuNameList.Length; i++)
            {
                this.spriteBatch.DrawString(this.font,
                    MenuNameList[i],
                    new Vector2(40.0f, 120.0f + i * 20.0f), Color.White);
            }

            // 各パラメータ //

            LightParameter selectedLight = this.lightParameters[this.selectedLightIndex];

            // ライトのインデックス
            this.parameters[0] = this.selectedLightIndex.ToString();

            // ライトの有効フラグ
            this.parameters[1] = selectedLight.Enabled.ToString();

            // ライトのディフーズカラー(赤)
            this.parameters[2] = selectedLight.DiffuseColor.X.ToString();

            // ライトのディフーズカラー(緑)
            this.parameters[3] = selectedLight.DiffuseColor.Y.ToString();

            // ライトのディフーズカラー(青)
            this.parameters[4] = selectedLight.DiffuseColor.Z.ToString();

            // ライトのスペキュラーカラー(赤)
            this.parameters[5] = selectedLight.SpecularColor.X.ToString();

            // ライトのスペキュラーカラー(緑)
            this.parameters[6] = selectedLight.SpecularColor.Y.ToString();

            // ライトのスペキュラーカラー(青)
            this.parameters[7] = selectedLight.SpecularColor.Z.ToString();

            // ライトの方向X
            this.parameters[8] = selectedLight.Direction.X.ToString();

            // ライトの方向Y
            this.parameters[9] = selectedLight.Direction.Y.ToString();

            // ライトの方向Z
            this.parameters[10] = selectedLight.Direction.Z.ToString();

            // アンビエントカラー(赤)
            this.parameters[11] = this.ambientLightColor.X.ToString();

            // アンビエントカラー(緑)
            this.parameters[12] = this.ambientLightColor.Y.ToString();

            // アンビエントカラー(青)
            this.parameters[13] = this.ambientLightColor.Z.ToString();

            // ピクセル単位のライティング
            this.parameters[14] = this.isPreferPerPixelLighting.ToString();


            for (int i = 0; i < this.parameters.Length; i++)
            {
                this.spriteBatch.DrawString(this.font,
                    this.parameters[i],
                    new Vector2(300.0f, 120.0f + i * 20.0f), Color.White);
            }

            // 選択インデックス
            this.spriteBatch.DrawString(this.font, "*",
                new Vector2(20.0f, 124.0f + this.selectedMenuIndex * 20.0f), Color.White);

            // スプライトの一括描画
            this.spriteBatch.End();

            // 登録された DrawableGameComponent を描画する
            base.Draw(gameTime);
        }
    }
}