Selecteer een model vanuit de positie op het scherm

Pagina bijgewerkt :
Aanmaakdatum van pagina :

samenvatting

Hiermee kunt u het model selecteren op de positie van de muiscursor. Wanneer u de muisaanwijzer op het model plaatst, verandert de tekst Treffer in Waar.

スクリーン上の位置からモデルを選択

Werkomgeving

Voorwaarden

Ondersteunde XNA-versies
  • 4.0
Ondersteunde platforms
  • Windows (XP SP2 of hoger, Vista, 7)
  • Xbox 360
  • Windows Phone 7
Windows vereist Vertex Shader-versie 2.0
Windows Vereiste Pixel Shader-versie 2.0

Werkomgeving

perron
  • Vensters 7
  • Xbox 360
  • Windows Phone 7-emulator

Hoe werkt u met het voorbeeld?

Werkt toetsenbordXbox 360-controllermuis aanraken
Cursor-beweging ↑↓←→ Linker joystick Beweging van de muis -

stof

Schermcoördinaten converteren naar ruimtelijke 3D-coördinaten

Misschien wilt u met een muis een model in de 3D-ruimte selecteren. In dit geval is het noodzakelijk om het tweedimensionale coördinatenpunt op het scherm om te zetten naar de driedimensionale coördinaat waar het model bestaat en een trefferbeoordeling uit te voeren.

Om het element uit te breiden van 2D naar 3D, is het echter niet mogelijk om een punt te vinden met 3D-coördinaten van 2D-schermcoördinaten van alleen X en Y. Als u zich bijvoorbeeld voorstelt dat u daadwerkelijk op het scherm klikt, zult u begrijpen dat het niet mogelijk is om te bepalen of de positie in de 3D-ruimte wanneer u klikt voor het object, het object zelf of achter het object is.

オブジェクトの選択対象の判断

Daarom wordt de aangeklikte positie niet weergegeven als een punt, maar als een lijn die is uitgerekt vanuit de camerapositie in de richting van de klik. Door botsingsdetectie tussen de lijn en het object uit te voeren, is het mogelijk om een model te selecteren. Trouwens, lijnparameters kunnen in XNA worden afgehandeld door een structuur die Ray wordt genoemd.

Krijg de positie in de 3D-ruimte vanuit de positie van het scherm

XNA heeft geen methode om een lijn te vinden in de richting van een klik op het scherm. Omdat het echter mogelijk is om een punt in de 3D-ruimte te vinden door de schermcoördinaten en diepte op te geven, is het mogelijk om een lijn te vinden door de positie van de camera en het 3D-ruimtecoördinatenpunt dat op een bepaalde diepte is getransformeerd, met elkaar te verbinden.

Het vinden van objectruimtecoördinaten uit schermruimtecoördinaten is eenvoudig te doen met behulp van de methode "Viewport.Unproject".

// ビューポートを取得
Viewport viewport = this.GraphicsDevice.Viewport;

// スクリーンの位置を Vector3 で作成 (Z は 1.0 以下を設定)
Vector3 screenPosition = new Vector3(this.markPosition, 1.0f);

// スクリーン座標を3次元座標に変換
Vector3 worldPoint = viewport.Unproject(screenPosition,
                                        this.projection,
                                        this.view,
                                        Matrix.Identity);

Het eerste argument is een Vector3 met schermcoördinaten en diepte. Stel X, Y in op de coördinaten van het scherm en Z op de dieptewaarde. De diepte is afhankelijk van de parameters "nearPlaneDistance" en "farPlaneDistance" van de projectiematrix, waarbij u 0.0f kunt opgeven om de afstand van de camerapositie tot nearPlaneDistance te vinden en 1.0f om de afstand van de camerapositie tot farPlaneDistance te bepalen.

Het tweede argument is de projectiematrix en het derde argument is de weergavematrix.

U kunt een object-ruimtevector vinden als de retourwaarde.

Viewport.Unproject methode

Projecteert een vector van de schermruimte naar de objectruimte.

bron Vector 3 Schermcoördinatenvector voor het converteren naar object-ruimtecoördinaten
projectie Matrix Projectieve matrix
bekijken Matrix Bekijk Matrix
wereld Matrix Specificeert de uiteindelijke transformatie van de wereldmatrixcoördinaten die moet worden uitgevoerd
Waarden retourneren Vector 3 Een vector in de objectruimte ophalen

Creëer een straal

Lijnparameters kunnen straalstructuren zijn. Het eerste argument voor de constructor is het beginpunt van de straal, en het tweede argument is de oriëntatie van de straal.

Stel de positie van de camera in als startpunt en bereken de oriëntatie door de positie van de camera af te trekken van de 3D-ruimtecoördinaten die al zijn omgezet in oriëntatie. De oriëntatie wordt ingesteld op een eenheidsvector met behulp van de methode Vector3.Normalize.

// マークが指す方向へのレイを作成
Ray ray = new Ray(this.cameraPosition,
                    Vector3.Normalize(worldPoint - this.cameraPosition));

Ray bouwer

Maak een instantie van de "Ray"-structuur die de parameters van de lijn bevat.

positie Vector 3 Het startpunt van de straal
richting Vector 3 Richting van de straal

Bal en straal hitbox

De ModelMesh-klasse die vanuit de inhoudspijplijn wordt geladen, bevat bolgegevens die de mazen omvatten, de eigenschap BoundingSphere genoemd. Door de straal die je zojuist hebt gemaakt op te geven in de methode Snijpunten van deze klasse, kun je controleren of de bol en de straal botsen.

In het geval van een botsing wordt de afstand tussen het begin van de straal en het botsingspunt teruggegeven. Als er geen botsing is, wordt null geretourneerd, zodat in het voorbeeld wordt gecontroleerd of er een botsing is door middel van een null-oordeel.

Deze methode gaat er echter van uit dat het model zich bij de oorsprong bevindt. Als u het model verplaatst, moet u de stralen transformeren terwijl het model beweegt.

Trouwens, dit voorbeeldmodel is een bol, dus ik denk dat het nauwkeurig kan worden bepaald.

// 球とレイとの当たり判定を行う
this.isHit = false;
foreach (ModelMesh mesh in this.model.Meshes)
{
    if (mesh.BoundingSphere.Intersects(ray) != null)
    {
        // 球とレイは交差している
        this.isHit = true;
        break;
    }
}

BoundingSphere.Intersects methode

Botsingsdetectie tussen de inclusieve bal en de straal wordt uitgevoerd.

straal Straal Straal om de botsing met de bal te beoordelen
Waarden retourneren Nietige<vlotter> In het geval van een botsing geeft het de afstand terug tussen het beginpunt van de straal en het punt van inslag met de bol. Als er geen botsing is, wordt null geretourneerd.

Alle codes

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 ModelSelectByScreenPosition
{
    /// <summary>
    /// ゲームメインクラス
    /// </summary>
    public class GameMain : Microsoft.Xna.Framework.Game
    {
        /// <summary>
        /// グラフィックデバイス管理クラス
        /// </summary>
        private GraphicsDeviceManager graphics = null;

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

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

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

        /// <summary>
        /// マーク
        /// </summary>
        private Texture2D mark = null;

        /// <summary>
        /// マーク画像の中心位置
        /// </summary>
        private Vector2 markCenterPosition = Vector2.Zero;

        /// <summary>
        /// マークの位置
        /// </summary>
        private Vector2 markPosition = new Vector2(100.0f, 100.0f);

        /// <summary>
        /// モデルへの当たり判定フラグ
        /// </summary>
        private bool isHit = false;

        /// <summary>
        /// カメラの位置
        /// </summary>
        private Vector3 cameraPosition = new Vector3(0.0f, 0.0f, 10.0f);

        /// <summary>
        /// ビューマトリックス
        /// </summary>
        private Matrix view;

        /// <summary>
        /// プロジェクションマトリックス
        /// </summary>
        private Matrix projection;


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

        /// <summary>
        /// ゲームが始まる前の初期化処理を行うメソッド
        /// グラフィック以外のデータの読み込み、コンポーネントの初期化を行う
        /// </summary>
        protected override void Initialize()
        {
            // ビューマトリックス
            this.view = Matrix.CreateLookAt(
                        this.cameraPosition,
                        Vector3.Zero,
                        Vector3.Up
                    );

            // プロジェクションマトリックス
            this.projection = Matrix.CreatePerspectiveFieldOfView(
                        MathHelper.ToRadians(45.0f),
                        (float)this.GraphicsDevice.Viewport.Width /
                            (float)this.GraphicsDevice.Viewport.Height,
                        1.0f,
                        100.0f
                    );

            // コンポーネントの初期化などを行います
            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();

                    // ビューマトリックスをあらかじめ設定
                    effect.View = this.view;

                    // プロジェクションマトリックスをあらかじめ設定
                    effect.Projection = this.projection;
                }
            }

            // マーク作成
            this.mark = this.Content.Load<Texture2D>("Mark");

            // マークの中心位置
            this.markCenterPosition = new Vector2(this.mark.Width / 2, this.mark.Height / 2);
        }

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

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

            // ゲームパッドの情報取得
            GamePadState gamePadState = GamePad.GetState(PlayerIndex.One);

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

            // 移動スピード
            float speed = 200.0f;

            // キーボードによるマークの移動
            if (keyboardState.IsKeyDown(Keys.Left))
            {
                this.markPosition.X -= speed * (float)gameTime.ElapsedGameTime.TotalSeconds;
            }
            if (keyboardState.IsKeyDown(Keys.Right))
            {
                this.markPosition.X += speed * (float)gameTime.ElapsedGameTime.TotalSeconds;
            }
            if (keyboardState.IsKeyDown(Keys.Up))
            {
                this.markPosition.Y -= speed * (float)gameTime.ElapsedGameTime.TotalSeconds;
            }
            if (keyboardState.IsKeyDown(Keys.Down))
            {
                this.markPosition.Y += speed * (float)gameTime.ElapsedGameTime.TotalSeconds;
            }

            // ゲームパッドによるマークの移動
            if (gamePadState.IsConnected)
            {
                this.markPosition.X += gamePadState.ThumbSticks.Left.X * speed *
                                       (float)gameTime.ElapsedGameTime.TotalSeconds;
                this.markPosition.Y -= gamePadState.ThumbSticks.Left.Y * speed *
                                       (float)gameTime.ElapsedGameTime.TotalSeconds;
            }

            // マウス処理
            MouseState mouseState = Mouse.GetState();

            if (mouseState.X >= 0 && mouseState.X < this.Window.ClientBounds.Width &&
                mouseState.Y >= 0 && mouseState.Y < this.Window.ClientBounds.Height &&
                mouseState.LeftButton == ButtonState.Pressed)
            {
                // マウスがウインドウ内にあればマウスの位置を優先する
                this.markPosition = new Vector2(mouseState.X, mouseState.Y);
            }

            // ビューポートを取得
            Viewport viewport = this.GraphicsDevice.Viewport;

            // スクリーンの位置を Vector3 で作成 (Z は 1.0 以下を設定)
            Vector3 screenPosition = new Vector3(this.markPosition, 1.0f);

            // スクリーン座標を3次元座標に変換
            Vector3 worldPoint = viewport.Unproject(screenPosition,
                                                    this.projection,
                                                    this.view,
                                                    Matrix.Identity);

            // マークが指す方向へのレイを作成
            Ray ray = new Ray(this.cameraPosition,
                              Vector3.Normalize(worldPoint - this.cameraPosition));

            // 球とレイとの当たり判定を行う
            this.isHit = false;
            foreach (ModelMesh mesh in this.model.Meshes)
            {
                if (mesh.BoundingSphere.Intersects(ray) != null)
                {
                    // 球とレイは交差している
                    this.isHit = true;
                    break;
                }
            }

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

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

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

            // モデルを描画
            foreach (ModelMesh mesh in this.model.Meshes)
            {
                mesh.Draw();
            }

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

            // マーク描画
            this.spriteBatch.Draw(this.mark, this.markPosition,
                null, Color.White, 0.0f,
                this.markCenterPosition, 1.0f, SpriteEffects.None, 0.0f);

            // テキスト描画
            this.spriteBatch.DrawString(this.font,
                "Cursor Key Press or" + Environment.NewLine +
                "   MouseLeftButton Drag" + Environment.NewLine +
                "Hit : " + this.isHit,
                new Vector2(50.0f, 50.0f), Color.White);

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

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