Đèn BasicEffect

tóm tắt

Thao tác các tham số liên quan đến phần ánh sáng của BasicEffect để xem mô hình được hiển thị như thế nào.

Môi trường hoạt động

Điều kiện tiên quyết

Môi trường hoạt động

Làm thế nào để làm việc với mẫu

chất

ánh sáng

Ánh sáng được sử dụng để đại diện cho bóng của một chất. Trong XNA, đèn không được đặt làm một trong các cài đặt môi trường, mà được đặt thành các hiệu ứng riêng lẻ.

Có ba nguồn sáng song song có sẵn trong BasicEffect và mỗi đèn có các tham số sau:

Ngoài ra còn có các tính chất phổ biến cho đèn riêng lẻ.

Hình ảnh thay đổi ánh sáng

Hình ảnh dưới đây cho thấy các giá trị khác nhau của đèn. Trong mẫu, cả ba đèn đều được bật, nhưng trong hình dưới đây, chỉ có một đèn được sử dụng để hiển thị nó.

Trạng thái ban đầu

Đây là trạng thái ngay sau khi tải dữ liệu mô hình mẫu.

Khuếch tánSửa đổi màu sắc

Thay đổi DiffuseColor của ánh sáng. Vì màu đỏ và xanh dương được đặt thành 0 và màu xanh lá cây được đặt thành 1, chỉ phần màu xanh lá cây của mô hình được tô sáng. (Màu đỏ và màu xanh cũng có thể nhìn thấy mờ nhạt, nhưng điều này là do ánh sáng xung quanh.)

SpecularThay đổi màu sắc

Thay đổi màu sắc của ánh sáng phản xạ. Vì chỉ có màu xanh lá cây được đặt, màu của phần phản chiếu chỉ là yếu tố màu xanh lá cây.

Thay đổi hướng đi

Bạn có thể thay đổi hướng của ánh sáng bằng cách thay đổi Hướng. Thông thường, chỉ có định hướng được sử dụng, vì vậy vectơ được chuẩn hóa.

Môi trường xung quanhLightColor Change

Đèn xung quanh màu đỏ và xanh lam được tối đa hóa và màu xanh lá cây được đặt thành 0. Nếu bạn nhìn vào những khu vực mà ánh sáng không chiếu vào, bạn có thể thấy rõ sự khác biệt giữa các sắc thái xanh lá cây, đỏ và xanh lam.

Sửa đổi PreferPerPixelLighting

Đặt PreferPerPixelLighting thành True để cho phép tính toán ánh sáng từng pixel. Thật khó để nhìn thấy trong sơ đồ, nhưng trong trường hợp ánh sáng cấp đỉnh, ranh giới của các đa giác bằng cách nào đó có thể nhìn thấy được, nhưng trong trường hợp ánh sáng từng pixel, bóng rất mịn có thể được thể hiện.

Nhân tiện, bạn không thể sử dụng thuộc tính PreferPerPixelLighting nếu bạn không hỗ trợ pixel shader 2.0. Ngoài ra, nếu bạn sử dụng nhiều đèn, nó có thể trông lạ.

Ánh sáng trên mỗi đỉnhÁnh sáng mỗi pixel

Định nghĩa lớp tham số cho đèn

Vì BasicEffect có thể có nhiều đèn, chúng tôi đã tạo một lớp để thiết lập các thông số ánh sáng. Các tham số giống như các tham số có thể được đặt cho đèn 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;
}

trường

Xác định các thông số cần thiết để thiết lập ánh sáng. Vì bạn có thể đặt ba đèn cho đèn, số lượng phần tử trong mảng cũng là ba. Các trường khác được sử dụng cho các thao tác menu, hiển thị ký tự, v.v., vì vậy vui lòng tham khảo mã đầy đủ.

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

Chuyển đổi ghi mặc định

Phương thức BasicEffect.EnableDefaultLighting đặt các tham số của ánh sáng được chỉ định bởi XNA Framework thành một hiệu ứng. Chúng tôi đang nhận được giá trị này để giữ nó trong trường một lần. (Trong mẫu, nó ở dạng mua nhiều lần, nhưng nó được đơn giản hóa vì sẽ dài nếu bạn viết mã để có được nó một cách riêng biệt.)

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

Thiết lập đèn

Tôi đang thiết lập một ánh sáng cho BasicEffect của mô hình. Giá trị chỉ đơn giản được đặt thành tham số ánh sáng của BasicEffect. Để biết mã của hoạt động thay đổi thông số ánh sáng, vui lòng tham khảo mã đầy đủ riêng biệt.

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 tài sản

BasicEffect.DirectionalLight1 tài sản

BasicEffect.DirectionalLight2 tài sản

BasicEffect.AmbientLightColor tài sản

BasicEffect.PreferPerPixelLighting tài sản

BasicDirectionalLight.Enabled tài sản

BasicDirectionalLight.DiffuseColor tài sản

BasicDirectionalLight.SpecularColor tài sản

BasicDirectionalLight.Direction tài sản

Tất cả các mã

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