Up Hill and Down Dale

Now we are walking, but as you have probably noticed, as soon as we get to the bumpy areas at the side of the world we start sinking into them- we are not walking up or down the hills, we are just ploughing through them as though they weren’t there at all. Which is, if you think about it, fair enough because we haven’t done anything to change the vertical position of the purple dude, we have just set up controls that allow him to move around on the flat. So next up we need to make him handle the ups and downs of the world.

The way we do this will be to use the picking capabilities of Java3D. These are based on the creation of a PickTool that enables us to create a picking shape. There are various shapes available to us, all extending javax.media.j3d.PickShape and each one offering a different shape that we can create and that will tell us what objects in the world intersect with it. For this task we will use a PickRay, which creates a straight line from a given point in a given direction. We can create this from the centre of our character straight down and then move him up or down according to where the ground is. This will require a few changes to the behaviour and the calling code –the PickRay will have to be created outside the behaviour and passed to it and we will have to set pickability so that the landscape can be picked but the character can’t.

So looking at ClimbMorph you will notice that only a couple of places have changed. First up we now have a private PickTool picker; declared and handed to the Behaviour when it is created. We also have a whole lot of changes to the moveStep method, which we will look at now:

So, first we have incremented upSum as before, then we have created a new point3d then transformed it to match our starting point but be 2 metres above it. This point will be the starting point for our picking ray, which will point straight down so that if the ground is anything less than 2 metres above our current position we will locate it.

We also create a Vector3d called “down”- I have said this before and I’ll say it again –3D graphics has a really strong element of performance tuning about it- a Vector3d that will never do anything but point down should never be created every frame- it should be a static class level variable. The only reason it is happening this way here is that I want to have as many code changes as possible in one place as it’s easier to see what is going on. You could probably go through most of the classes here as an exercise and see how you could make them more efficient.

The PickRay has a starting point and a direction, both of which we just defined.

Now we have used pickClosest to find the first intersection the PickRay finds and return it’s PickIntersection object. We then get it’s point co-ordinates and load them into our point.

if (nextpoint != null)
{
double pickY = (pickStart.y);
pickY = pickY-2.0;
if (nextpoint.y != pickY)
{
Vector3d translate = new Vector3d();
ourTrans.get(translate);
translate.y=nextpoint.y;
ourTrans.setTranslation(translate);
}
}
tempTrans.setTranslation(new Vector3d(0.0d, 0.0d, stepper));
}

So if our point has been created properly we create a double to contain the position of our starting point ( we subtract 2 because we started 2 metres off the ground ) and make sure that the point we have just picked is not the same as the previous y position –no point doing all this work if it is.