public override void _Process(float delta)
    {
        loopCount++;

        var localRight = Transform.basis.Column0;
        var localUp    = Transform.basis.Column1;
        var localFwd   = Transform.basis.Column2;


        Translate(Vector3.Forward * delta * 10);

        //var targetDiff = GlobalTransform.origin - steerTarget;

        var desiredXform = GlobalTransform.LookingAt(steerTarget, Vector3.Up);

        GlobalTransform = GlobalTransform.InterpolateWith(desiredXform, 1f * delta);

        //        Transform.Rotated(Vector3.Up)

        //Transform.
        //Transform.InterpolateWith

        if (loopCount % 100 == 0)
        {
            GD.Print($"{loopCount / 100}: localFwd={localFwd.ToString("F2")}");
        }

        //Transform.InterpolateWith

        //GD.Print("steerTarget", steerTarget);
    }
示例#2
0
 private void AlignCarWithGround()
 {
     if (Down.IsColliding())
     {
         var n = Down.GetCollisionNormal().Normalized();
         GlobalTransform = GlobalTransform.InterpolateWith(GlobalTransform.LookingAtWithY(n), .1f);
     }
 }
示例#3
0
 public override void _PhysicsProcess(float delta)
 {
     if (lerp_towards_target)
     {
         GlobalTransform = GlobalTransform.InterpolateWith(target, lerp_speed * delta);
     }
     else
     {
         GlobalTransform = GlobalTransform.InterpolateWith(initial_transform, lerp_speed * delta);
     }
 }
    // Called every frame. 'delta' is the elapsed time since the previous frame.
    public override void _PhysicsProcess(float delta)
    {
        if (Target != null)
        {
            var targetPos = Target.GlobalTransform.Translated(Offset);
            GlobalTransform = GlobalTransform.InterpolateWith(targetPos, LerpSpeed * delta);
            LookAt(Target.GlobalTransform.origin, Vector3.Up);

            if (LockYPos)
            {
                this.SetGlobalOriginY(OriginalPos.y);
            }

            if (LockYRot)
            {
                this.SetGlobalBasisY(OriginalRot.y);
            }

            GlobalTransform = GlobalTransform.Orthonormalized();
        }
    }
示例#5
0
    public override void _PhysicsProcess(float delta)
    {
        Vector3 rot = desiredAnchorRotation;

        rot.x = Mathf.Clamp(rot.x, -90, 90f);

        desiredAnchorRotation = rot;

        Transform desiredT = Transform.Identity;

        desiredT.origin = desiredAnchorPosition;
        desiredT.basis  = new Basis(new Quat(
                                        desiredAnchorRotation * Mathf.Deg2Rad(1f)
                                        ));

        float t = Mathf.Clamp(lerpSpeed * delta, 0f, 1f);

        GlobalTransform = GlobalTransform.InterpolateWith(
            desiredT, t
            );

        desiredCameraZoom = Mathf.Clamp(desiredCameraZoom, Near * 4f, Far * .5f);
        cameraZoom        = Mathf.Lerp(cameraZoom, desiredCameraZoom, t);
    }