How do I determine the direction the camera is facing?

unicornlox

In Godot, when you hold down the Shift key and press the middle mouse button and drag the mouse, you move around the world in a sliding motion. I want to do this kind of movement with the camera. How can I detect the direction the camera is looking in and do this kind of sliding in a 3D scene?

spaceyjase

It might help here to think of the Camera as just another Node with a transform, which can then be moved just like any other node with a transform. That is, the Camera's forward direction is the same, e.g. transform.basis.z. More can be read about here: Using 3D transforms.

Moving it around is also the same! A node would typically respond to an InputEventPanGesture and changing the transform appropriately. Worth checking the example projects here on 3D movement.

unicornlox

spaceyjase thank you very much for your reply, it looks like I have some work to do🙂

unicornlox

the following codes are working.

using Godot;
using System;

public partial class SquareFloor : Node3D
{
    private Camera3D _camera;
    private PlaneMesh _planeMesh;
    private ShaderMaterial _planeMeshMaterial;

    private float _zoomAmount = 1.0f;
    private bool _isShiftPressed = false;
    private bool _isMiddleMousePressed = false;

    public override void _Ready()
    {
        _camera = GetNode<Camera3D>("Camera3D");
        _planeMesh = (PlaneMesh) GetNode<MeshInstance3D>("MeshInstance3D").Mesh;
        _planeMeshMaterial = (ShaderMaterial) _planeMesh.Material;

        _planeMeshMaterial.SetShaderParameter("fadeDistance", 100.0f);
        _planeMeshMaterial.SetShaderParameter("unitSize", 1.0f);
    }

    public override void _Process(double delta)
    {
    }

    public override void _UnhandledInput(InputEvent @event)
    {
        if (@event is InputEventKey keyEvent && keyEvent.IsActionPressed("Shift"))
        {
            _isShiftPressed = true;
        }
        else if (@event is InputEventKey keyEventR && keyEventR.IsActionReleased("Shift"))
        {
            _isShiftPressed = false;
        }

        if (@event is InputEventMouseButton mouseMotionEvent)
        {
            if (mouseMotionEvent.ButtonIndex == MouseButton.Middle && mouseMotionEvent.IsPressed())
            {
                _isMiddleMousePressed = true;
            }
            else if (mouseMotionEvent.ButtonIndex == MouseButton.Middle && mouseMotionEvent.IsReleased())
            {
                _isMiddleMousePressed = false;
            }
            else if (mouseMotionEvent.ButtonIndex == MouseButton.WheelUp && mouseMotionEvent.IsPressed())
            {
                if (_isShiftPressed)
                {
                    MoveCameraY(-_zoomAmount);
                }
                else
                {
                    Zoom(-0.01f);
                }
            }
            else if (mouseMotionEvent.ButtonIndex == MouseButton.WheelDown && mouseMotionEvent.IsPressed())
            {
                if (_isShiftPressed)
                {
                    MoveCameraY(_zoomAmount);
                }
                else
                {
                    Zoom(0.01f);
                }
            }
        }

        if (@event is InputEventMouseMotion mouseSlideEvent && _isShiftPressed && _isMiddleMousePressed)
        {
            MoveCamera(mouseSlideEvent.Relative);
        }
    }

    private void MoveCamera(Vector2 delta)
    {
        Vector3 cameraDirection = _camera.GlobalTransform.Basis.X.Normalized();
        Vector3 newCameraPosition = _camera.GlobalTransform.Origin - cameraDirection * (delta.X*0.005f) + _camera.GlobalTransform.Origin * (delta.Y*0.005f);

        _camera.GlobalTransform = new Transform3D(_camera.GlobalTransform.Basis.X, _camera.GlobalTransform.Basis.Y, _camera.GlobalTransform.Basis.Z, newCameraPosition);
    }

    private void MoveCameraY(float delta)
    {
        Vector3 CameraPosition = _camera.GlobalTransform.Origin;
        CameraPosition.Y += delta;

        _camera.GlobalTransform = new Transform3D(_camera.GlobalTransform.Basis.X, _camera.GlobalTransform.Basis.Y, _camera.GlobalTransform.Basis.Z, CameraPosition);
    }

    private void Zoom(float delta)
    {
        _camera.Near += delta;
        _camera.Near = Mathf.Clamp(_camera.Near, 0.1f, 100.0f);
    }

    private void ChangeShaderParam()
    {
    }
}