Dibujar un polígono trigonal usando un búfer de vértices

resumen

Mediante el uso de búferes de vértices, los polígonos se pueden dibujar rápidamente.

Entorno operativo

Prerrequisitos

Entorno operativo

sustancia

Cuando dibujas un polígono, puedes dibujarlo usando algo llamado "búfer de vértices". El búfer de vértices se puede rellenar con datos de vértices que se utilizarán al dibujar primitivas como polígonos. El búfer de vértices permite que los datos de vértices se coloquen en la memoria de vídeo, y la canalización de dibujo puede intercambiar datos mucho más rápido que lo hace desde la memoria principal normal, por lo que se puede esperar que mejore la velocidad de dibujo.

En el caso de un solo polígono como este, no puedes sentir que estás dibujando a gran velocidad, pero creo que el efecto es visible al dibujar miles o decenas de miles de polígonos.

campo

/// <summary>
/// 頂点バッファ
/// </summary>
private VertexBuffer vertexBuffer = null;

Para usar un búfer de vértices, use la clase "VertexBuffer". Si los datos de vértice definidos por el usuario se enviaban a la canalización cada vez que se dibujaban, los datos de vértice debían conservarse en todo momento, pero si se creaba un búfer de vértices, el búfer de vértices administra los datos de vértices, por lo que no es necesario conservar los datos de vértices.

Creación de un búfer de vértices

// 頂点の数
int vertexCount = 3;

// 頂点バッファ作成
this.vertexBuffer = new VertexBuffer(this.GraphicsDevice,
    typeof(VertexPositionColor), vertexCount, BufferUsage.None);

En el método LoadGraphicsContent, estamos creando un VertexBuffer.

El primer argumento es un GraphicsDevice.

El segundo argumento especifica el tipo de estructura que contiene los datos de vértice, o la declaración de vértice de los datos de vértice que se van a utilizar. Aquí, typeof se pasa en el tipo de la estructura. Dado que "posición de vértice" y "color de vértice" se usan para los datos de vértice, la estructura "VertexPositionColor" proporcionada por XNA Framework se especifica como estándar.

El tercer argumento especifica el número de vértices que se van a crear.

El cuarto argumento especifica el uso del búfer de vértices, pero si no hay nada en particular, puede especificar "BufferUsage.None".

VertexBuffer constructor

Cree una instancia de la clase "VertexBuffer" para crear datos de vértices.

// 頂点データを作成する
VertexPositionColor[] pointList = new VertexPositionColor[vertexCount];

pointList[0] = new VertexPositionColor(new Vector3(0.0f, 3.0f, 0.0f), Color.Red);
pointList[1] = new VertexPositionColor(new Vector3(3.0f, -2.0f, 0.0f), Color.Blue);
pointList[2] = new VertexPositionColor(new Vector3(-3.0f, -2.0f, 0.0f), Color.Green);

// 頂点データを頂点バッファに書き込む
this.vertexBuffer.SetData(pointList);

Después de crear el búfer de vértices, establezca el búfer de vértices con datos de vértices. Para establecer datos de vértices, use el método "VertexBuffer.SetData".

Una vez que los datos de vértices se establecen en el búfer de vértices, el búfer de vértices los administra, por lo que si ya no los usa, puede descartarlos tal como están.

VertexBuffer.SetData método

Establezca los datos de vértices en el búfer de vértices.

dibujo

// 描画に使用する頂点バッファをセットします
this.GraphicsDevice.SetVertexBuffer(this.vertexBuffer);

// パスの数だけ繰り返し描画
foreach (EffectPass pass in this.basicEffect.CurrentTechnique.Passes)
{
    // パスの開始
    pass.Apply();

    // 三角形を描画する
    this.GraphicsDevice.DrawPrimitives(PrimitiveType.TriangleList, 0, 1);
}

Para dibujar un polígono, defina el búfer de vértices que se utilizará para dibujar. GraphicsDevice tiene un método "SetVertexBuffer" que establece el búfer de vértices en él.

GraphicsDevice.SetVertexBuffer método

Especifica la zona de influencia de vértices que se va a utilizar para el dibujo.

Para dibujar los polígonos reales, use el método "GraphicsDevice.DrawPrimitives". Si desea utilizar un búfer de vértices, lo dibujará con este método. A diferencia del método DrawUserPrimitives, que especifica los datos de puntos definidos por el usuario tal cual, este método se usa para dibujar mediante un búfer de vértices.

El primer argumento es el tipo de primitiva que se va a dibujar, el segundo argumento es el índice de vértices para empezar a dibujar y el tercer argumento es el número de primitivas que se van a dibujar.

GraphicsDevice.DrawPrimitives método

Dibuja un primitivo utilizando el búfer de vértices especificado.

Todos los códigos

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

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

        /// <summary>
        /// 頂点バッファ
        /// </summary>
        private VertexBuffer vertexBuffer = null;

        /// <summary>
        /// 基本エフェクト
        /// </summary>
        private BasicEffect basicEffect = null;


        /// <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()
        {
            // TODO: ここに初期化ロジックを書いてください

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

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

            // エフェクトを作成
            this.basicEffect = new BasicEffect(this.GraphicsDevice);

            // エフェクトで頂点カラーを有効にする
            this.basicEffect.VertexColorEnabled = true;

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

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

            // 頂点の数
            int vertexCount = 3;

            // 頂点バッファ作成
            this.vertexBuffer = new VertexBuffer(this.GraphicsDevice,
                typeof(VertexPositionColor), vertexCount, BufferUsage.None);

            // 頂点データを作成する
            VertexPositionColor[] pointList = new VertexPositionColor[vertexCount];

            pointList[0] = new VertexPositionColor(new Vector3(0.0f, 3.0f, 0.0f), Color.Red);
            pointList[1] = new VertexPositionColor(new Vector3(3.0f, -2.0f, 0.0f), Color.Blue);
            pointList[2] = new VertexPositionColor(new Vector3(-3.0f, -2.0f, 0.0f), Color.Green);

            // 頂点データを頂点バッファに書き込む
            this.vertexBuffer.SetData(pointList);
        }

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

        /// <summary>
        /// 描画以外のデータ更新等の処理を行うメソッド
        /// 主に入力処理、衝突判定などの物理計算、オーディオの再生など
        /// </summary>
        /// <param name="gameTime">このメソッドが呼ばれたときのゲーム時間</param>
        protected override void Update(GameTime gameTime)
        {
            // Xbox 360 コントローラ、Windows Phone の BACK ボタンを押したときに
            // ゲームを終了させます
            if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed)
            {
                this.Exit();
            }

            // TODO: ここに更新処理を記述してください

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

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

            // 描画に使用する頂点バッファをセットします
            this.GraphicsDevice.SetVertexBuffer(this.vertexBuffer);

            // パスの数だけ繰り返し描画
            foreach (EffectPass pass in this.basicEffect.CurrentTechnique.Passes)
            {
                // パスの開始
                pass.Apply();

                // 三角形を描画する
                this.GraphicsDevice.DrawPrimitives(PrimitiveType.TriangleList, 0, 1);
            }

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