如何确保Libgdx坐标系原点始终位于屏幕左下角？

Hey there! Let's get that coordinate system sorted out so your particle simulation renders with the origin firmly fixed at the screen's bottom-left, no matter how you resize the window. Here's a breakdown of what's likely going wrong and how to fix it:

1. Understand the Default SpriteBatch Coordinate System #

First, remember that SpriteBatch defaults to a top-left origin for rendering. If your Camera isn't adjusting for this, you'll end up with the origin shifted somewhere unexpected (like that top-left quarter spot you're seeing). To flip this to bottom-left, we need to adjust the projection matrix your Camera uses.

2. Set Up a Proper Orthographic Projection Matrix #

The key is using an orthographic projection that explicitly maps world coordinate (0,0) to the screen's bottom-left corner. Here's how to implement this in your Camera class (assuming you're using a framework like MonoGame/XNA, since you mentioned SpriteBatch):

public class Camera
{
    private int _screenWidth;
    private int _screenHeight;
    private Matrix _projectionMatrix;

    public void Initialize(int initialWidth, int initialHeight)
    {
        UpdateProjection(initialWidth, initialHeight);
    }

    public void UpdateProjection(int newWidth, int newHeight)
    {
        _screenWidth = newWidth;
        _screenHeight = newHeight;
        // Create an orthographic projection that places (0,0) at bottom-left, (width, height) at top-right
        _projectionMatrix = Matrix.CreateOrthographicOffCenter(
            0,                      // Left edge of the view (world X=0 maps to screen left)
            _screenWidth,           // Right edge (world X=width maps to screen right)
            0,                      // Bottom edge (world Y=0 maps to screen bottom)
            _screenHeight,          // Top edge (world Y=height maps to screen top)
            0,                      // Near plane (irrelevant for 2D)
            1                       // Far plane (irrelevant for 2D)
        );
    }

    public Matrix GetViewProjectionMatrix()
    {
        // If your Camera doesn't move (fixed position), the view matrix is just identity
        var viewMatrix = Matrix.Identity;
        return viewMatrix * _projectionMatrix;
    }
}

3. Use the Camera Matrix in SpriteBatch #

When you start your SpriteBatch render pass, pass the Camera's combined view-projection matrix to ensure all particle positions are mapped correctly to the bottom-left origin:

// In your Draw method
spriteBatch.Begin(
    sortMode: SpriteSortMode.Deferred,
    blendState: BlendState.AlphaBlend,
    transformMatrix: _camera.GetViewProjectionMatrix()
);

// Draw your particles here using their world coordinates (where (0,0) is bottom-left)
foreach(var particle in _particles)
{
    spriteBatch.Draw(_particleTexture, particle.Position, Color.White);
}

spriteBatch.End();

4. Handle Window Resize Correctly #

The big issue causing the origin to shift on resize is that your Camera's projection matrix isn't updating to match the new screen dimensions. Hook into your framework's resize event to refresh the projection:

// For MonoGame, override OnResize in your Game class
protected override void OnResize(EventArgs e)
{
    base.OnResize(e);
    // Update the Camera with the new viewport size
    _camera.UpdateProjection(GraphicsDevice.Viewport.Width, GraphicsDevice.Viewport.Height);
}

Why This Works #

By using Matrix.CreateOrthographicOffCenter, we're explicitly defining how world coordinates map to screen pixels. This overrides SpriteBatch's default top-left origin and locks (0,0) to the bottom-left. Updating the projection on resize ensures the mapping stays consistent even when the window changes size.

If you were previously using Matrix.CreateOrthographic without the off-center parameters, that's likely why your origin was shifted—it defaults to centering the world in the viewport, which would push (0,0) to a corner relative to the screen size.

内容的提问来源于stack exchange，提问作者Francisco Ayala Lebrun