XNA - 关于世界空间和屏幕空间之间的关系

Question

编辑：只是想让我的问题更清楚。我几乎很难看到像 Matrix.CreateTransformationZ 这样的东西不仅在矩阵乘法的背景下如何工作，而且更重要的是它对屏幕空间/世界空间的作用，这样我才能得到更清晰的图片。因此，也许有人可以更改代码或给我一个简短的片段来测试我可以在哪里使用它来绕轴旋转和/或绕轴轨道运行。我也改变了这个例子。

所以我仍然很难想象矩阵如何与 xna 屏幕空间一起工作。

我给你举个例子：

public class Game1 : Microsoft.Xna.Framework.Game
{
    Texture2D shipTexture, rockTexture;


    Vector2 shipPosition = new Vector2(100.0f, 100.0f);
    Vector2 rockPosition = new Vector2(100.0f, 29.0f);

    int count;

    float shipRotation, rockRotation;
    float rockSpeed, rockRotationSpeed;
    bool move = true;

    const int rock = 0;
    const int ship = 1;

    Color[] rockColor;
    Color[] shipColor;

    float testRot = 0.0f;
    Vector2 shipCenter; int shipWidth, shipHeight;
    Vector2 rockCenter; int rockWidth, rockHeight;

    GraphicsDeviceManager graphics;
    SpriteBatch spriteBatch;

    #region maincontent
    public Game1()
    {
        graphics = new GraphicsDeviceManager(this);
        Content.RootDirectory = "Content";
    }

    /// <summary>
    /// Allows the game to perform any initialization it needs to before starting to run.
    /// This is where it can query for any required services and load any non-graphic
    /// related content.  Calling base.Initialize will enumerate through any components
    /// and initialize them as well.
    /// </summary>
    protected override void Initialize()
    {
        // TODO: Add your initialization logic here
        rockSpeed = 0.16f;
        rockRotationSpeed = 0.3f;
        base.Initialize();
    }



    /// <summary>
    /// LoadContent will be called once per game and is the place to load
    /// all of your content.
    /// </summary>
    protected override void LoadContent()
    {
        shipTexture = Content.Load<Texture2D>("Images\\ship");
        rockTexture = Content.Load<Texture2D>("Images\\asteroid");

        rockWidth = rockTexture.Width; rockHeight = rockTexture.Height;
        shipWidth = shipTexture.Width; shipHeight = shipTexture.Height;

        rockCenter = new Vector2(rockWidth / 2, rockHeight / 2);
        shipCenter = new Vector2(shipWidth / 2, shipHeight / 2);



        // Create a new SpriteBatch, which can be used to draw textures.
        spriteBatch = new SpriteBatch(GraphicsDevice);

        // TODO: use this.Content to load your game content here
        rockColor = new Color[rockTexture.Width * rockTexture.Height];
        rockTexture.GetData(rockColor);
        shipColor = new Color[shipTexture.Width * shipTexture.Height];
        shipTexture.GetData(shipColor);
    }

    /// <summary>
    /// UnloadContent will be called once per game and is the place to unload
    /// all content.
    /// </summary>
    protected override void UnloadContent()
    {
        // TODO: Unload any non ContentManager content here
    }

            /// <summary>
    /// This is called when the game should draw itself.
    /// </summary>
    /// <param name="gameTime">Provides a snapshot of timing values.</param>
    protected override void Draw(GameTime gameTime)
    {
        GraphicsDevice.Clear(Color.CornflowerBlue);

        spriteBatch.Begin(SpriteBlendMode.AlphaBlend);

        spriteBatch.Draw(rockTexture, rockPosition,
            null, Color.White, testRot, rockCenter, 1.0f,
            SpriteEffects.None, 0.0f);

        spriteBatch.Draw(shipTexture, shipPosition,
            null, Color.White, shipRotation, shipCenter,
            1.0f, SpriteEffects.None, 0.0f);

        spriteBatch.End();
        // TODO: Add your drawing code here

        base.Draw(gameTime);
    }
    #endregion

    /// <summary>
    /// Allows the game to run logic such as updating the world,
    /// checking for collisions, gathering input, and playing audio.
    /// </summary>
    /// <param name="gameTime">Provides a snapshot of timing values.</param>
    protected override void Update(GameTime gameTime)
    {
        testRot += 0.034906585f;
        // Allows the game to exit
        if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed)
            this.Exit();

        UpdateAsteroid(gameTime);
        RotateShip(gameTime);
        MoveShip(gameTime);
        // TODO: Add your update logic here
        CheckCollisions();
        base.Update(gameTime);
    }

    #region Collisions

    public Color PixelColor(int objectNum, int pixelNum)
    {
        switch (objectNum)
        {
            case rock:
                return rockColor[pixelNum];
            case ship:
                return shipColor[pixelNum];
        }

        return Color.White;
    }

    public bool PixelCollision(Matrix transformA, int pixelWidthA, int pixelHeightA, int A,
        Matrix transformB, int pixelWidthB, int pixelHeightB, int B)
    {
        Matrix temp = Matrix.Invert(transformB);
        Matrix AtoB = transformA * Matrix.Invert(transformB);

        Vector2 columnStep, rowStep, rowStartPosition;

        columnStep = Vector2.TransformNormal(Vector2.UnitX, AtoB);
        rowStep = Vector2.TransformNormal(Vector2.UnitY, AtoB);

        rowStartPosition = Vector2.Transform(Vector2.Zero, AtoB);

        for (int rowA = 0; rowA < pixelHeightA; rowA++)
        {
            // begin at the left
            Vector2 pixelPositionA = rowStartPosition;

            // for each column in the row (move left to right)
            for (int colA = 0; colA < pixelWidthA; colA++)
            {
                // get the pixel position
                int X = (int)Math.Round(pixelPositionA.X);
                int Y = (int)Math.Round(pixelPositionA.Y);

                // if the pixel is within the bounds of B
                if (X >= 0 && X < pixelWidthB && Y >= 0 && Y < pixelHeightB)
                {

                    // get colors of overlapping pixels
                    Color colorA = PixelColor(A, colA + rowA * pixelWidthA);
                    Color colorB = PixelColor(B, X + Y * pixelWidthB);

                    // if both pixels are not completely transparent,
                    if (colorA.A != 0 && colorB.A != 0)
                        return true; // collision
                }
                // move to the next pixel in the row of A
                pixelPositionA += columnStep;
            }

            // move to the next row of A
            rowStartPosition += rowStep;
        }

        return false; // no collision
    }
    public Matrix Transform(Vector2 center, float rotation, Vector2 position)
    {

        return Matrix.CreateTranslation(new Vector3(-center, 0.0f)) *
            Matrix.CreateRotationZ(rotation) *
            Matrix.CreateTranslation(new Vector3(position, 0.0f));
    }

    public static Rectangle TransformRectangle(Matrix transform, int width, int height)
    {
        Vector2 leftTop = new Vector2(0.0f, 0.0f);
        Vector2 rightTop = new Vector2(width, 0.0f);
        Vector2 leftBottom = new Vector2(0.0f, height);
        Vector2 rightBottom = new Vector2(width, height);

        Vector2.Transform(ref leftTop, ref transform, out leftTop);
        Vector2.Transform(ref rightTop, ref transform, out rightTop);
        Vector2.Transform(ref leftBottom, ref transform, out leftBottom);
        Vector2.Transform(ref rightBottom, ref transform, out rightBottom);

        Vector2 min = Vector2.Min(Vector2.Min(leftTop, rightTop), Vector2.Min(leftBottom, rightBottom));
        Vector2 max = Vector2.Max(Vector2.Max(leftTop, rightTop), Vector2.Max(leftBottom, rightBottom));

        return new Rectangle((int)min.X, (int)min.Y,
            (int)(max.X - min.X), (int)(max.Y - min.Y));
    }

    private void CheckCollisions()
    {
        Matrix shipTransform, rockTransform;

        Rectangle shipRectangle, rockRectangle;

        rockTransform = Transform(rockCenter, rockRotation, rockPosition);
        rockRectangle = TransformRectangle(rockTransform, rockWidth, rockHeight);
        shipTransform = Transform(shipCenter, shipRotation, shipPosition);
        shipRectangle = TransformRectangle(shipTransform, shipWidth, shipHeight);

        if (rockRectangle.Intersects(shipRectangle)) // rough collision check
            if (PixelCollision( // exact collision check
            rockTransform, rockWidth, rockHeight, rock,
            shipTransform, shipWidth, shipHeight, ship))
                move = false;
    }
    #endregion

    #region Moves_and_Rotations

    private void UpdateAsteroid(GameTime gameTime)
    {
        float timeLapse = (float)gameTime.ElapsedGameTime.Milliseconds;

        if (move == true)
        {
            if ((rockWidth + rockPosition.X >= Window.ClientBounds.Width))
            {
                rockSpeed *= -1.0f;
                rockPosition.X += rockSpeed * timeLapse;
            }
            else if ((rockPosition.X <= 0))
            {
                rockSpeed *= -1.0f;
                rockPosition.X += rockSpeed * timeLapse;

            }
            else
                rockPosition.X += rockSpeed * timeLapse;

            const float SCALE = 50.0f;
            rockRotation += rockRotationSpeed * timeLapse / SCALE;

            rockRotation = rockRotation % (MathHelper.Pi * 2.0f);
        }
    }

    private float RotateShip(GameTime gameTime)
    {
        float rotation = 0.0f;
        float speed = gameTime.ElapsedGameTime.Milliseconds / 300.0f;

        if (!move)
            return rotation;

        KeyboardState keyboard = Keyboard.GetState();

        if (keyboard.IsKeyDown(Keys.Right))
            rotation = speed;
        else if (keyboard.IsKeyDown(Keys.Left))
            rotation = -speed;

        shipRotation += rotation;

        shipRotation = shipRotation % (MathHelper.Pi * 2.0f);
        return shipRotation;
    }

    private void MoveShip(GameTime gameTime)
    {
        const float SCALE = 20.0f;
        float speed = gameTime.ElapsedGameTime.Milliseconds / 100.0f;

        KeyboardState keyboard = Keyboard.GetState();

        if (keyboard.IsKeyDown(Keys.Up))
        {

            shipPosition.X += (float)Math.Sin(shipRotation) * speed * SCALE;
            shipPosition.Y -= (float)Math.Cos(shipRotation) * speed * SCALE;
        }
        else if (keyboard.IsKeyDown(Keys.Down))
        {
            shipPosition.X -= (float)Math.Sin(shipRotation) * speed * SCALE;
            shipPosition.Y += (float)Math.Cos(shipRotation) * speed * SCALE;
        }
    }
#endregion
}

我从 XNA Game Creators 那里得到了这个，它只是一种进行像素检测的方法。

1. 在上面的 Transform 方法中，我猜是针对矩形进行矩阵乘法。就屏幕空间/世界空间而言到底发生了什么？

2. 为什么作者要将这个矩阵乘以另一个矩阵的逆矩阵？ （他提到，不知何故，这使得它相对于其他资产）

Answer 1

屏幕空间大概与客户端空间相同。客户端空间从左上角的 (0,0) 到右下角的 (宽度, 高度)。 “向上”是Y-。

投影空间从左下角的 (-1,-1) 到右上角的 (1,1)。这就是 GPU 用于最终渲染的内容。 SpriteBatch 会为您处理此问题（相比之下：BasicEffect 要求您提供投影矩阵）。

世界空间是您想要的任何空间。这是您的游戏发生的坐标系。在您的示例中，这似乎与客户端空间相同。

传统上，在执行此类操作时，您会在自己的空间中定义一个对象。在您的示例中，岩石和船舶矩形被硬编码到函数 TransformRectangle 中，作为变量 topLeft 到 bottomRight 的初始值。

然后，每个对象就有一个世界矩阵。这会将对象从其自己的空间移动到其在世界空间中的位置。在您的示例中，这是 shipTransform 和 rockTransform。世界变换也在SpriteBatch.Draw内部完成，基于您传入的参数（使用纹理本身作为初始对象）。

然后你就有了一个视图矩阵 - 你可以将其视为你的相机。你的例子没有其中之一。但是，例如，如果您想要平移视图以跟随玩家，则可以在此处使用根据玩家位置创建的平移矩阵（并将其传递给 SpriteBatch.Begin）。

最后，您有一个投影矩阵，它将您的世界空间转换为投影空间，以便 GPU 可以渲染您的场景。

现在这里可能存在的问题是 SpriteBatch 内部定义了一个将客户端空间转换为投影空间的投影矩阵（因此它基本上“假设”世界空间是客户端空间）。在您的示例中这不是问题，因为两个空格相同。

如果您的世界空间与客户端空间不同，并且您想要使用 SpriteBatch，则必须创建一个额外的矩阵以从世界空间转换为客户端空间，并将其插入视图矩阵和项目矩阵之间（即：将其与 View 相乘并将其传递给 SpriteBatch.Begin）。

如果您的世界空间定义的“向上”（或“向右”）方向与 SpriteBatch 不同，那么您必须记住 SpriteBatch.Draw 使用的原始对象定义“向上” “是Y-。

Answer 2

我不认为是空间关系导致了您所看到的（在问题的第一版中）。该矩阵在其所在空间方面具有灵巧性。如果您向其提供屏幕空间值，它就会返回屏幕空间值。所以关系（屏幕/世界）不相关也不存在。

例如，如果您想使用矩阵使飞船围绕 2d 屏幕的中心点运行：

Vector2 screenCenter = new Vec2(width/2, h/2);// abbreviated
Vector2 shipPosition = screenCenter;
shipPosition.X += 25;//offset ship from center slightly

shipPosition = Vector2.Transform(shipPosition, Matrix.CreateTranslation(-screenCenter));
shipPosition = Vector2.Transform(shipPosition , Matrix.CreateRotationZ(someRadians));
shipPosition = Vector2.Transform(shipPosition , Matrix.CreateTranslation(screenCenter));


//although the above would typically be written as:
shipPosition = Vector2.Transform(shipPosition - screenCenter, Matrix.CreateRotationZ(someAngle)) + screenCenter;

请注意，所有值都只是屏幕空间值。世界/屏幕空间关系并不重要。这就是如何使用矩阵在 2d 屏幕空间中围绕另一个点旋转一个点。对于 3d 来说，这将是精确的代码，但带有 Z 分量（向量 3）并使用 3d 世界空间。

您的comboMatrix（来自早期代码）和新代码片段中的transform()可能会让您感到困惑。将矩阵相乘时，就像将一个旋转与另一个旋转相加。所以你的comboMatrix就像3 + 5 +(-3)...你真正做的只是相当于5。你的comboMatrix所做的只是相当于rotZ...它没有翻译。和你的 Transform() 类似。当我将三个矩阵应用于上面的 ShipPosition 时，我确保在进行下一个操作之前将每个矩阵应用于 ShipPosition。有时您可以在应用之前连接矩阵，但就您而言，不能。

这有帮助还是我仍然错过了你的问题？

Answer 3

在 TestMatrix() 中：

shipPosition = Vector2.Transform(shipPosition, rotZ);

应该是

ShipPosition = Vector2.Transform(shipPosition,comboMatrix);

Answer 4

概念：-平移、旋转、+平移。是一种使物体旋转或旋转的机制。
但你将它应用到一个点（向量2）。点旋转几乎没有什么用处。我相信你真正想要的是让船精灵原地旋转。这通常是通过更改 ShipRotation 变量来完成的，该变量是一个浮点数，描述您希望精灵旋转的角度差值（从 0 开始）。

由于某种原因，您将点（shipPosition）的旋转与船舶对象的旋转混淆了......

在 2d 中，尽管矩阵中的数学工作与 3d 中一样好，但 spritebatch.Draw() 方法使用单个float 来描述旋转，并且与 Matrix 生成的旋转数据没有直接关系。

有趣的是，在二维中使用矩阵来变换点是很好的，但很多人不明白这一点。在这里，您试图理解它，但真正希望它作用于一个对象而不是一个点。所以，不要放弃矩阵。但只需更改 Draw 调用内的旋转值即可将精灵旋转到位。

现在，如果我未能解释您的目标，请告诉我，我会尽力提供进一步帮助。