The panda is moving just like before, but now an ActorInterval we create in the highlighted line of the code controls animation playback. We set the animation to loop and to play over the duration of five seconds. Finally, the animation-controlling ActorInterval and the Sequence of transformations are made part of a Parallel that plays the two intervals at the same time.

The actor interval constructor can take a range of optional parameters besides loop and duration that were already presented in the sample code. Let's take a look at what else you can do with ActorInterval:

Instead of duration, you can use startTime and endTime to define more precisely when to start and stop playing the animation.

The playrate parameter lets you set the animation playback speed. Also note that if playrate is a negative value, the animation is played backwards.

You can specify a sub range of the animation to be played by setting startFrame and endFrame. Also, if you want to loop an animation range, set constrainedLoop to one instead of loop.

In the following line of code, all these options have been applied to our sample code to loop the first second of the walk animation at a very low rate:

self.pandaAnim = ActorInterval(self.panda, "walk", startTime = 0, endTime = 1, playrate = 0.1, constrainedLoop = 1, duration = 5)

To follow this recipe you first have to set up a project as described in Setting up the game structure. In addition, you need to create a curve in Maya or Blender and export it to Panda3D's .egg file format. In case you don't have these tools or do not know how to work with them, here's a sample curve you can paste into a text editor and save it as path.egg:

<CoordinateSystem> { Z-up }
<Group> Curve {
<VertexPool> Curve {
<Vertex> 0 {
-2.66117048264 -0.964361846447 0.0 1.0
}
<Vertex> 1 {
1.8930850029 -0.948404431343 0.0 1.0
}
<Vertex> 2 {
10.3484048843 1.0 0.0 1.0
}
<Vertex> 3 {
-3.6957449913 0.0 0.0 1.0
}
}
<NURBSCurve> {
<Order> { 4 }
<Knots> { 0.0 0.0 0.0 0.0 1.0 1.0 1.0 1.0 }
<VertexRef> { 0 1 2 3 <Ref> { Curve }}
}
}

Making objects follow a predefined path can be done like the following:

All it takes for you to use predefined paths is to create a Mopath object and load the file containing the curve you want your object to follow. Then you pass the Mopath object to a MopathInterval that is responsible for interpolating the model position along the path over the specified duration. That's it—it's that easy!

See the recipe Setting up the game structure to create the basic application framework for the following steps.

Let's build a third person camera system:

We use the constructor of our Application class to set up the scene containing the walking panda and the background scenery. In the last line we create a new instance of our FollowCam, which contains the camera tracking code that is the core of this recipe.

To make the FollowCam work correctly and to be able to have multiple cameras follow different objects, we have to pass the camera we want to be updated and its target to the constructor, where we set up a few things we need for updating the camera. For example, we add a task that will call the updateCamera() method each frame. Additionally, the target's name is appended to both the dummy object's and the task's names to avoid name clashes in the case where we need to use more than one FollowCam instance. The dummy object is an invisible helper object that will help us to position the camera, as you will see in the following paragraphs.

The updateCamera() method is where all the work is happening: We move the dummy to our target's current position and get its current heading. The heading angle (in degrees) is clamped to the range of values from 180 to 180. We do this to avoid the camera getting stuck or continuing to turn because of the ambiguous nature of angles.

In the next steps, we calculate the difference between the target's heading and that of our dummy object, which is also clamped to avoid the undesired results described in the previous paragraph. In the following lines we can find the explanation for the camera's smooth turning—every frame, the dummy object's heading converges towards the heading of the camera target just a little bit. This is intentional; as it is multiplied by the time it took to complete the last frame. Additionally, we can also influence how fast the camera turns by adjusting turnRate.

In the final steps, the camera is first moved to the position of the dummy and then pushed away again along the dummy's local axis to its final position. After setting the camera's lookAt() target, we are done!

In this version, the camera only supports smooth turning for objects that only change their heading. Other rotation axes can be added rather easily, as they work exactly the same as the one presented in this recipe!

As a prerequisite to the following steps, please create a new project as described in the recipe Setting up the game structure. This recipe can be found in the Chapter 1.

You will also need a texture image. Preferably it should be rectangular and in the best case be in a 2n format (64x64, 128x128, 256x256, and so on.). This recipe will use a crate texture in PNG format.

Lastly, add a directory called textures to your project and be sure it is in Panda3D's search path. This works analogous to what you did for the models and sounds directories.

Follow these steps to learn how to create geometry on the fly:

Let's take a look at what this code is doing! We begin by creating a format descriptor for one of Panda3D's built in vertex data layouts. There are several of these layouts, which also can be completely customized, which describe what kind of data will be stored for each point in space that forms the mesh. In this particular case, we are using the getV3t2() method to get a descriptor for a vertex layout that stores the vertex position in space using three floating point values and the texture coordinate using two float values.

We then move on to create a GeomVertexData object, which uses the format we just requested. We also pass the Geom.UHStatic flag, which signals the underlying rendering systems that the vertex data will not change, which allows them to enable some optimizations. Additionally, we create two GeomVertexWriter objects—one for writing to the "vertex" channel, which stores the positions of the points that form the mesh, and the other one for writing to the "texcoord" channel of the point data we are adding to geomData in the loop that follows.

What we have so far is a cloud of seemingly random points—at least to the engine. To correct this issue, we need to connect the points to form primitives, which in this case are triangles. We create a new instance of GeomTriangles, using the Geom.UHStatic flag again to hint that the primitives will not be changed after they are defined. Then we create two triangles by passing indices to the proper points in the vertices list. After each triangle, we need to call the closePrimitive() method to mark the primitive as complete and start a new one.

At this point we have a collection of points in space, stored in a GeomVertexData object and a GeomTriangles primitive that holds the information necessary to connect the dots and form a mesh. To get the model to the screen, we need to create a new Geom, and add the point data and the triangle primitives. Because a model can in fact consist of multiple Geom objects, which also can't be added directly to the scene graph, we add it to a GeomNode. Finally, we attach the GeomNode to the scene graph, load and apply the texture and set the camera a bit back to be able to see our creation.

There's a lot more to say about Panda3D's procedural geometry feature than what you just saw, so take your time and keep on reading to discover what else you can do to generate geometry at runtime.

arrayFmt = GeomVertexArrayFormat()
arrayFmt.addColumn(InternalName.make("normal"), 3, Geom.NTFloat32, Geom.CVector)
fmt = GeomVertexFormat()
fmt.addArray(arrayFmt)
fmt = GeomVertexFormat.registerFormat(fmt)

Loading models and actors, Modifying the scene graph.

For this recipe you will need to set up the basic framework described in Setting up the game structure.

Follow these steps to create a sample application that demonstrates asynchronous data loading:

The previous code enqueues calls to the load() method using doMethodLater() so you can see the objects pop up as soon as they are loaded. The list passed to the extraArgs parameter will be used as parameters for the call to load().

The call to loadModel() within the load method is very important, because instead of just passing the name of the model to load, you also set the callback parameter to one of the modelLoaded() and actorLoaded() methods, depending on what the cb parameter of load() contains.

As soon as a call to loadModel() uses the callback parameter, the request to load the data is handed off to a background thread. When the required asset has finished loading, the callback function is called and the loaded asset is passed as the first parameter, as you can see in the modelLoaded() and actorLoaded() methods.