LibGdx鼠标位置相对于正交相机而不是屏幕

Question

基本上我写了一个基于OrthographicCameralibgdx 的"Dota like Style" .你可以在这里测试一下这个课程.

我正在使用它来绘制TiledMap,并且我有与图形图块对应的图块阵列,但是如果我移动鼠标,那么就是相机.
鼠标和瓷砖的坐标完全不同.
Gdx.inputx和y得到它们相对于屏幕的坐标,而不是相对于相机的鼠标在世界中的位置.

我无法弄清楚相对于相机获取鼠标位置的方法,所以如果我移动相机我不会只获得常规鼠标坐标,而是相机显示的实际世界坐标,以及我的位置鼠标位于相机相对于世界的视野范围内.

public class DotaCamera extends OrthographicCamera {

    private float xmin;
    private float xmax;
    private float ymin;
    private float ymax;

    private float x;
    private float y;

    private int Width = Gdx.graphics.getWidth();;
    private int Height = Gdx.graphics.getHeight();

    private int camSpeedMax = 16;
    private float camAcceleration = 0.3f;
    private int camSpeedSmoother = 3;

    private float camVelocityX = 0;
    private float camVelocityY = 0;

    private float fZoomMax = 1f;
    private float fZoomMin = 0.5f;
    private float fZoomSpeed = 0.03f;

    public DotaCamera() {
        this(0, 0, 0, 0);
    }

    public DotaCamera(float xmin, float xmax, float ymin, float ymax) {
        super();
        setBounds(xmin, xmax, ymin, ymax);
    }

    public void setBounds(float xmin, float xmax, float ymin, float ymax) {
        this.xmin = xmin;
        this.xmax = xmax;
        this.ymin = ymin;
        this.ymax = ymax;
    }

    public void setPosition(float x, float y) {
        setPosition(x, y, 0);
    }

    public void setPosition(float x, float y, float z) {
        position.set(x, y, z);
        this.x = x;
        this.y = y;
        fixBounds();
    }

    private void fixBounds() {
        if (position.x < xmin + viewportWidth / 2) {
            position.x = xmin + viewportWidth / 2;
        }
        if (position.x > xmax - viewportWidth / 2) {
            position.x = xmax - viewportWidth / 2;
        }
        if (position.y < ymin + viewportHeight / 2) {
            position.y = ymin + viewportHeight / 2;
        }
        if (position.y > ymax - viewportHeight / 2) {
            position.y = ymax - viewportHeight / 2;
        }
    }

    /**
     * Controls the zoom of the of the camera.
     */
    public void updateZoom() {
        int mouseWheelMovement = Mouse.getDWheel();
        if (mouseWheelMovement > 0) {
            if (this.zoom > fZoomMin) {
                this.zoom -= fZoomSpeed;
            } else {
                this.zoom = fZoomMin;
            }
        }else if(mouseWheelMovement < 0){
            if (this.zoom < fZoomMax) {
                this.zoom += fZoomSpeed;
            } else {
                this.zoom = fZoomMax;
            }
        }
    }

    /**
     * Update And move the Camera DOTA Stylized movement.
     */
    public void updateAndMove() {
        float dt = Gdx.graphics.getDeltaTime();

        int MouseX = Mouse.getX(); // Get MouseX
        int MouseY = Height - Mouse.getY(); // Get MouseY

        int camSpeedX = 0;
        int camSpeedY = 0;

        String horizontalDirection = getMoveLeftRight(MouseX); // Get
                                                                // horizontalDirection
        String verticalDirection = getMoveUpDown(MouseY); // Get
                                                            // verticalDirection

        /* * * * * * * *
         * Decide what to do with the horizontalDirection.
         */
        switch (horizontalDirection) {
        case "left":
            camSpeedX = ((Width / 2) - (MouseX + (Width / 4)))
                    / camSpeedSmoother; // Create Speed -X

            camSpeedX = ((camSpeedX > camSpeedMax) ? camSpeedMax : camSpeedX); // Limit
                                                                                // the
                                                                                // speed.
            if (camVelocityX < camSpeedX)
                camVelocityX += camAcceleration;
            break;
        case "right":
            camSpeedX = (((MouseX + (Width / 4)) - ((Width / 4) * 3)) - (Width / 4))
                    / camSpeedSmoother; // Create speed +X.

            camSpeedX = ((camSpeedX > camSpeedMax) ? camSpeedMax : camSpeedX); // Limit
                                                                                // the
                                                                                // speed.

            if (camVelocityX < camSpeedX)
                camVelocityX += camAcceleration; // Accelerate

            camSpeedX *= -1; // To negate the speed.
            break;
        case "":
            camVelocityX = 0;
            break;
        }

        /* * * * * * * *
         * Decide what to do with the verticalDirection.
         */
        switch (verticalDirection) {
        case "up":
            camSpeedY = (Height / 4) - MouseY; // Create speed -Y

            camSpeedY = ((camSpeedY > camSpeedMax) ? camSpeedMax : camSpeedY); // Limit
                                                                                // the
                                                                                // speed.

            if (camVelocityY < camSpeedY)
                camVelocityY += camAcceleration;

            camSpeedY *= -1;
            break;
        case "down":
            camSpeedY = (((MouseY + (Height / 4)) - ((Height / 4) * 3)) - (Height / 4))
                    / camSpeedSmoother; // Create speed +Y.

            camSpeedY = ((camSpeedY > camSpeedMax) ? camSpeedMax : camSpeedY); // Limit
                                                                                // the
                                                                                // speed.
            if (camVelocityY < camSpeedY)
                camVelocityY += camAcceleration;
            break;
        case "":
            camVelocityY = 0;
            break;
        }

        // System.out.println("vX:" +camVelocityX+ "vY: " +camVelocityY+ "sX: "
        // +camSpeedX+ "sY: " +camSpeedY);

        this.position.x -= (camVelocityX * camSpeedX) * dt;
        this.position.y -= (camVelocityY * camSpeedY) * dt;
        this.update();
    }

    /**
     * Get the X-Axial Direction.
     * 
     * @param MouseX
     * @return Direction
     */
    private String getMoveLeftRight(int MouseX) {
        if (MouseX + (Width / 4) < Width / 2) {// Needs to move left?
            return "left";
        } else if (MouseX > (Width / 4) * 3) {// Needs to move right?
            return "right";
        }
        return "";
    }

    /**
     * Get the Y-Axial Direction.
     * 
     * @param MouseY
     * @return Direction
     */
    private String getMoveUpDown(int MouseY) {
        if (MouseY < Height / 4) {// Needs to move up?
            return "up";
        } else if (MouseY > (Height / 4) * 3) {// Needs to move down?
            return "down";
        }
        return "";
    }

Answer 1

碰到这个问题并在这里找到答案:

https://gamedev.stackexchange.com/questions/27786/camera-coordinate-to-screen-coordinate

据说,使用Camera.unproject(Vector3 screenCoords)是正确的方法.

我的解决方案如下所示:

Vector3 getMousePosInGameWorld() {
 return camera.unproject(new Vector3(Gdx.input.getX(), Gdx.input.getY(), 0));
}