ChaseCamera fixed angle along the vehicle motion

Pavl_G · February 16, 2021, 12:21pm

I would like to know , how can i have a constant horizontally rotated chascamera that’s able to rotate with the car wheels or the car chassis in order to achieve the camera being always looking at the back of the car only.

Something like need for speed , i think jme-vehicles has something like that , but i am lost in the source …

this is my code , it’s working but not very efficient when moving very fast:

package com.myGame.JmEGamePadExample;

import com.jme3.bullet.control.VehicleControl;
import com.jme3.input.ChaseCamera;
import com.jme3.math.FastMath;
import com.scrappers.superiorExtendedEngine.gamePad.GameStickView;


public class GameStick implements GameStickView.GameStickListeners {
    
    private VehicleControl vehicleControl;
    private final float accelerationForce = FastMath.pow(5, 3.5f);
    private static final float brakeForce = 300f;
    private float accelerationValue = 0;
    private ChaseCamera chaseCamera;
    private static float defaultAngle=-(FastMath.PI +FastMath.HALF_PI);

    public float getAccelerationValue() {
        return accelerationValue;
    }

    public float getAccelerationForce() {
        return accelerationForce;
    }


    public void setVehicleControl(VehicleControl vehicleControl) {
        this.vehicleControl = vehicleControl;
    }

    public void setAccelerationValue(float accelerationValue) {
        this.accelerationValue = accelerationValue;
    }

    public void setChaseCamera(ChaseCamera chaseCamera) {
        this.chaseCamera = chaseCamera;
        chaseCamera.setDefaultDistance(-25f);
        chaseCamera.setDefaultVerticalRotation(-FastMath.PI/10);
        chaseCamera.setDefaultHorizontalRotation(-(FastMath.PI + FastMath.HALF_PI));
    }

    @Override
    public void accelerate(final float pulse) {
        accelerationValue+=pulse;
        accelerationValue+=accelerationForce;
        vehicleControl.accelerate(0,accelerationValue);
        vehicleControl.accelerate(1,accelerationValue);
    }

    @Override
    public void reverseTwitch(float pulse) {
        vehicleControl.accelerate(-accelerationForce*2);
        vehicleControl.brake(brakeForce/2);
    }

    @Override
    public void steerRT(float pulse) {
        vehicleControl.steer(pulse/10);
        if(vehicleControl.getWheel(0).getEngineForce()>0f){
            chaseCamera.setDefaultHorizontalRotation(chaseCamera.getHorizontalRotation() + (-pulse / 80));
        }
    }

    @Override
    public void steerLT(float pulse) {
        vehicleControl.steer(pulse/8);
        if(vehicleControl.getWheel(1).getEngineForce()>0f){
            chaseCamera.setDefaultHorizontalRotation(chaseCamera.getHorizontalRotation() + (-pulse / 80));
        }
    }

    @Override
    public void neutralizeState(float pulseX, float pulseY) {
        vehicleControl.accelerate(0);
        vehicleControl.clearForces();
        vehicleControl.steer(0);
    }
}

so , can i tweak this code to make it work ,?

adi.barda · February 16, 2021, 12:31pm

camera.setTrailingEnabled(true);

Pavl_G · February 16, 2021, 1:14pm

it gives a weird chasing behavior of the car :

sgold · February 16, 2021, 7:48pm

jme-vehicles uses a physics-based camera controller named OrbitCamera from the “Garrett” library. The code that configures the camera controller is here:

github.com

stephengold/jme-vehicles/blob/5bb6ca6832288f9b49b173efbb2446d566227146/HelloMav/src/main/java/com/jayfella/jme/vehicle/simpledemo/HelloMav.java#L172


      
              vehicle.setAccelerateSignal(strength);
          
              updateTurn(tpf);
          }
          // *************************************************************************
          // private methods
          
          /**
           * Initialize the default Camera and its controller.
           */
          private void initCamera() {
              cam.setLocation(new Vector3f(291f, 12f, 2_075f));
              cam.setRotation(new Quaternion(0f, 0.9987554f, -0.05f, 0f));
              flyCam.setEnabled(false);
          
              OrbitCamera cameraController = new OrbitCamera(cam, signalTracker);
              cameraController.setChaseOption(ChaseOption.StrictFollow);
              Target cameraTarget = new Target() {
                  @Override
                  public Vector3f forwardDirection(Vector3f storeResult) {
                      Vector3f result = vehicle.forwardDirection(storeResult);

and the code the implements it is here:

github.com

stephengold/Garrett/blob/4e641595bf493b4414bced47836feb978552f235/GarrettLibrary/src/main/java/com/github/stephengold/garrett/OrbitCamera.java#L478


      
              enable();

          }

          

          /**

           * Callback to update this state prior to rendering. (Invoked once per frame

           * while the state is attached and enabled.)

           *

           * @param tpf the time interval between frames (in seconds, &ge;0)

           */

          @Override

          public void update(float tpf) {

              super.update(tpf);

          

              if (target == null) {

                  disable();

                  return;

              }

              PhysicsCollisionObject targetPco = target.getTargetPco();

              if (targetPco == null) {

                  disable();

                  return;

Pavl_G · February 16, 2021, 9:16pm

Aha yes , Garret Orbital camera , I have taken a look at it but I would like to know what’s SignalTrack , so what should I parse at that parameter !?

sgold · February 16, 2021, 9:40pm

SignalTracker keeps track of whether certain keys/buttons are pressed. It’s implemented in the “Heart” library:

github.com

stephengold/Heart/blob/5ffd657db3a4dc53bce3136f3a51de34d31e62f2/HeartLibrary/src/main/java/jme3utilities/SignalTracker.java#L43


import java.util.logging.Level;
import java.util.logging.Logger;

/**
 * Track the active/inactive status of named signals. A signal may originate
 * from multiple sources such as buttons or hotkeys. A signal is active as long
 * as any of its sources is active.
 *
 * @author Stephen Gold sgold@sonic.net
 */
public class SignalTracker {
    // *************************************************************************
    // constants and loggers

    /**
     * message logger for this class
     */
    final public static Logger logger
            = Logger.getLogger(SignalTracker.class.getName());
    // *************************************************************************
    // fields

and in HelloMav, it’s configured using the mapKeyToSignal() method:

github.com

stephengold/jme-vehicles/blob/5bb6ca6832288f9b49b173efbb2446d566227146/HelloMav/src/main/java/com/jayfella/jme/vehicle/simpledemo/HelloMav.java#L210


    stateManager.attach(cameraController);
}
/**
 * Add an input mapping that causes the SignalTracker to track the specified
 * key.
 *
 * @param key the key to be tracked
 * @param signalName name for the input signal (not null)
 */
private void mapKeyToSignal(int key, String signalName) {
    signalTracker.add(signalName);
    ActionListener rightListener = (action, keyPressed, tpf) -> {
        signalTracker.setActive(signalName, 0, keyPressed);
    };
    String action = "signal " + signalName;
    inputManager.addListener(rightListener, action);
    KeyTrigger trigger = new KeyTrigger(key);
    inputManager.addMapping(action, trigger);

Pavl_G · February 16, 2021, 11:36pm

I suppose it’s a nullabe value then .

sgold · February 16, 2021, 11:49pm

As the javadoc indicates, it’s not nullable. However, if you don’t intend to use any keys or buttons to control the camera, you can construct a SignalTracker using the default constructor and pass that.

Pavl_G · February 17, 2021, 12:45am

Thank you , I will try it