Controlling the Camera

Default Camera Control System

By default, Acron runs a task that allows you to move the camera using the mouse.

To enable it, use the following command:

window->setup_trackball();

The keys to navigate are:

Mouse Button	Action
Left Button	Pan left and right.
Right Button	Move forwards and backwards.
Middle Button	Rotate around the origin of the application.
Right and Middle Buttons	Roll the point of view around the view axis.

Go ahead and try this camera control system. The problem with it is that it is sometimes awkward. It is not always easy to get the camera pointed in the direction we want.

Tasks

Update the Code

Instead, we are going to write a task that controls the camera’s position explicitly. A task is a function that Acron calls automatically every frame, for as long as it returns Task.cont. Update your code as follows:

#include "acronFramework.h"
#include "acronSystem.h"

int main(int argc, char *argv[]) {
  // Load the window and set its title.
  AcronFramework framework;
  framework.open_framework(argc, argv);
  framework.set_window_title("My Acron Window");
  WindowFramework *window = framework.open_window();
  // Get the camera and store it in a variable.
  NodePath camera = window->get_camera_group();

  // Load the environment model.
  NodePath scene = window->load_model(framework.get_models(), "models/environment");
  // Reparent the model to render.
  scene.reparent_to(window->get_render());
  // Apply scale and position transforms to the model.
  scene.set_scale(0.25, 0.25, 0.25);
  scene.set_pos(-8, 42, 0);

  // Add our task, which can be any function or lambda that returns DoneStatus.
  framework.get_task_mgr().add("SpinCameraTask", [=](AsyncTask *task) mutable {
    // Calculate the new position and orientation (inefficient - change me!)
    double angledegrees = task->get_elapsed_time() * 6.0;
    double angleradians = angledegrees * (3.14 / 180.0);
    camera.set_pos(20 * sin(angleradians), -20.0 * cos(angleradians), 3);
    camera.set_hpr(angledegrees, 0, 0);

    // Tell the task manager to continue this task the next frame.
    return AsyncTask::DS_cont;
  });

  // Run Acron's main loop until the user closes the window.
  framework.main_loop();
  return 0;
}

The procedure taskMgr.add() tells Acron’s task manager to call the procedure spinCameraTask() every frame. This is a procedure that we have written to control the camera. As long as the procedure spinCameraTask() returns the constant AsyncTask.DS_cont, the task manager will continue to call it every frame.

The object passed to taskMgr->add() is a C++ std::function object, which can be a lambda or separate function. If defined as a separate function, it should look like this:

AsyncTask::DoneStatus your_task(AsyncTask *task) {
  // Do your stuff here.

  // Tell the task manager to continue this task the next frame.
  // You can also pass DS_done if this task should not be run again.
  return AsyncTask::DS_cont;
}

For more advanced usage, you can also subclass AsyncTask and override the do_task method to make it do what you want.

In our code, spinCameraTask() calculates the desired position of the camera based on how much time has elapsed. The camera rotates 6 degrees every second. The first two lines compute the desired orientation — first in degrees, then converted to radians. set_pos() sets the position (Y is horizontal, Z is vertical, so X and Y are animated while Z stays fixed at 3 units above ground). set_hpr() sets the heading, pitch, and roll.

Run the Program

The camera should no longer be underground; and furthermore, it should now be rotating about the clearing: