Φώτα BasicEffect

περίληψη

Χειριστείτε τις παραμέτρους που σχετίζονται με το φωτεινό τμήμα του BasicEffect για να δείτε πώς εμφανίζεται το μοντέλο.

Περιβάλλον λειτουργίας

Προϋποθέσεις

Περιβάλλον λειτουργίας

Πώς να εργαστείτε με το δείγμα

ουσία

φως

Τα φώτα χρησιμοποιούνται για να αναπαραστήσουν τις σκιές μιας ουσίας. Στο XNA, τα φώτα δεν ορίζονται ως μία από τις ρυθμίσεις περιβάλλοντος, αλλά ρυθμίζονται σε μεμονωμένα εφέ.

Υπάρχουν τρεις παράλληλες πηγές φωτός διαθέσιμες στο BasicEffect και κάθε φως έχει τις ακόλουθες παραμέτρους:

Υπάρχουν επίσης ιδιότητες που είναι κοινές σε μεμονωμένα φώτα.

Εικόνα αλλαγής φωτός

Η παρακάτω εικόνα δείχνει τις διαφορετικές τιμές των φώτων. Στο δείγμα, και οι τρεις λυχνίες είναι ενεργοποιημένες, αλλά στην παρακάτω εικόνα, χρησιμοποιείται μόνο μία λυχνία για την εμφάνισή της.

Αρχική κατάσταση

Αυτή είναι η κατάσταση αμέσως μετά τη φόρτωση των δεδομένων του δείγματος μοντέλου.

Τροποποίηση DiffuseColor

Αλλαγή του DiffuseColor του φωτός. Επειδή το κόκκινο και το μπλε έχουν οριστεί σε 0 και το πράσινο έχει οριστεί σε 1, επισημαίνεται μόνο το πράσινο τμήμα του μοντέλου. (Το κόκκινο και το μπλε είναι επίσης αμυδρά ορατά, αλλά αυτό οφείλεται στο φως του περιβάλλοντος.)

SpecularColor Αλλαγή

Αλλαγή του χρώματος του ανακλώμενου φωτός. Δεδομένου ότι έχει οριστεί μόνο πράσινο, το χρώμα του ανακλαστικού τμήματος είναι μόνο το πράσινο στοιχείο.

Αλλαγή κατεύθυνσης

Μπορείτε να αλλάξετε την κατεύθυνση του φωτός αλλάζοντας την κατεύθυνση. Κανονικά, χρησιμοποιείται μόνο προσανατολισμός, οπότε ο φορέας κανονικοποιείται.

AmbientLightColor Αλλαγή

Τα κόκκινα και μπλε φώτα περιβάλλοντος μεγιστοποιούνται και το πράσινο έχει οριστεί σε 0. Αν κοιτάξετε τις περιοχές όπου το φως δεν λάμπει, μπορείτε να δείτε καθαρά τη διαφορά μεταξύ πράσινων, κόκκινων και μπλε αποχρώσεων.

Τροποποίηση PreferPerPixelLighting

Ορίστε την τιμή PreferPerPixelLighting σε True για να επιτρέψετε υπολογισμούς φωτισμού pixel-by-pixel. Είναι δύσκολο να δούμε στο διάγραμμα, αλλά στην περίπτωση φωτισμού σε επίπεδο κορυφής, τα όρια των πολυγώνων είναι κάπως ορατά, αλλά στην περίπτωση του φωτισμού pixel-by-pixel, μπορούν να εκφραστούν πολύ ομαλές σκιές.

Παρεμπιπτόντως, δεν μπορείτε να χρησιμοποιήσετε την ιδιότητα PreferPerPixelLighting εάν δεν υποστηρίζετε pixel shader 2.0. Επίσης, εάν χρησιμοποιείτε πολλά φώτα, μπορεί να φαίνεται περίεργο.

Φωτισμός ανά κορυφήΦωτισμός ανά pixel

Ορισμοί κλάσης παραμέτρων για φώτα

Δεδομένου ότι το BasicEffect μπορεί να έχει πολλαπλά φώτα, δημιουργήσαμε μια κλάση για τη ρύθμιση παραμέτρων φωτός. Οι παράμετροι είναι ίδιες με αυτές που μπορούν να οριστούν για ένα φως BasicEffect (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;
}

αγρός

Καθορίζει τις παραμέτρους που απαιτούνται για τη ρύθμιση του φωτός. Δεδομένου ότι μπορείτε να ορίσετε τρία φώτα για φώτα, ο αριθμός των στοιχείων στον πίνακα είναι επίσης τρία. Τα άλλα πεδία χρησιμοποιούνται για λειτουργίες μενού, εμφάνιση χαρακτήρων κ.λπ., οπότε ανατρέξτε στον πλήρη κώδικα.

/// <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;

Προεπιλεγμένη λήψη εγγραφής

Η μέθοδος BasicEffect.EnableDefaultLighting ορίζει τις παραμέτρους ενός φωτός που καθορίζεται από το XNA Framework σε εφέ. Παίρνουμε αυτήν την τιμή για να την κρατήσουμε στο πεδίο μία φορά. (Στο δείγμα, έχει τη μορφή απόκτησης πολλές φορές, αλλά απλοποιείται επειδή θα είναι μεγάλο αν γράψετε κώδικα για να τον αποκτήσετε ξεχωριστά.)

// ライトとビュー、プロジェクションはあらかじめ設定しておく
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;
    }
}

Ρύθμιση των φώτων

Βάζω ένα φως στο BasicEffect του μοντέλου. Η τιμή απλώς ορίζεται στην παράμετρο light του BasicEffect. Για τον κωδικό της λειτουργίας αλλαγής παραμέτρων φωτός, ανατρέξτε ξεχωριστά στον πλήρη κωδικό.

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 ιδιοκτησία

BasicEffect.DirectionalLight1 ιδιοκτησία

BasicEffect.DirectionalLight2 ιδιοκτησία

BasicEffect.AmbientLightColor ιδιοκτησία

BasicEffect.PreferPerPixelLighting ιδιοκτησία

BasicDirectionalLight.Enabled ιδιοκτησία

BasicDirectionalLight.DiffuseColor ιδιοκτησία

BasicDirectionalLight.SpecularColor ιδιοκτησία

BasicDirectionalLight.Direction ιδιοκτησία

Όλοι οι κωδικοί

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);
        }
    }
}