I was under the impression this still wasn't permitted since you couldn't distribute derivatives of the poser models?

No matter
I have uploaded it to here and you can download it at your leisure. I've zipped it up, so it's only 9 kB.

During the rendering, it makes absolutely no difference if I do:

camera.setBack(storedDirection[0].getRotationMatrix().invert3x3());

or

camera.setBack(storedDirectionMatrix[0]);

i.e. setting the camera matrix to the stored direction matrix instead of a calculation on the stored direction vector has no effect (which I would expect).

In the swap function (which I previously supplied) the camera matrix is being set by performing a calculation on the vector:
camera.setBack(swap2.getRotationMatrix().invert3x3());
.

I had understood from this thread that the accepted way to set a camera's direction (as provided by getDirection()) was to do: theVector.getRotationMatrix().invert3x3()

That's all I'm really doing here. The same technique has worked in all the other cases that I've provided - even in the FPS example itself
 

The view is inverted in two places. One in which the camera/stored values are swapped (which is called twice) and one in which the scene is rendered.

Removing the invert from the swap function causes the display to flicker between two viewpoints. It looks as if it changes between the camera direction and 90 degrees to the camera angle. But it's hard to tell.

Removing the invert from the rendering function (in gameLoop) reverses the left/right rotation as well as causing the forward/backward controls to strafe left/right.

Removing the invert from both functions causes flickering, similar to the first case.

Agh!

I've come across a problem, and I cannot figure out if it's a bug in JPCT or a bug in my code. I've double and triple checked everything and I cannot seem to find the cause of the problem.

I have reproduced the problem by modifying the fps demo. My aim is to store independent camera settings in a set of object array variables. Note that in this example, there is only one setting in the arrays:

private SimpleVector[] storedPosition = {new SimpleVector(STARTING_POS)};
private SimpleVector[] storedDirection = {new SimpleVector()};
private Matrix[] storedPlayerDirection = {new Matrix()};

A new function swaps the camera object with one of the values in the settings. Again, for the purposes of this demo, the value which is swapped in is arbitrarily fixed at index 0.

protected void swapCameraWithStoredVariables()
{
SimpleVector swap;
SimpleVector swap2;
Matrix otherSwap;

swap = storedPosition[0];
storedPosition[0] = camera.getPosition();
camera.setPosition(swap);

swap2 = storedDirection[0];
storedDirection[0] = camera.getDirection();
camera.setBack(swap2.getRotationMatrix().invert3x3());

otherSwap = storedPlayerDirection[0];
storedPlayerDirection[0] = playerDirection;
playerDirection = otherSwap;
}

This function (swapCameraWithStoredVariables ) gets called at the top and bottom of the doMovement() function.

Finally, in gameLoop, I added two lines to set the camera to use the stored values. This occurs immediately before the poll() function:

camera.setPosition(storedPosition[0]);
camera.setBack(storedDirection[0].getRotationMatrix().invert3x3());

Once more, in this example, the camera is set to display a single camera.

To my knowledge, adding this code should have no effect to the operation of the fps demo. All it does is copy the stored variables in to the current camera to carry out any movement. When the movement is calculated, the values are copied back to the stored variables. When the scene is displayed, the variables are loaded in to the camera object.
Therefore, it should behave as the original fps does.

However, in practice, the forward/backward controls move at right angles to the camera direction. For example, if the camera is pointing straight ahead, the forward/backward controls move the camera left and right (strafing).

I cannot for the life of me, determine why this is happening. Is it a bug in my code, or a bug in jpct?

I can supply the modified fps demo code if required.

Hello!

I was wondering if anyone could give some guidance as to the resource usage of animated models. I'm considering buying some "game ready" animated 3D characters, but I'm not certain whether their use is appropriate for JPCT.

The animation I'm interested in uses 1700 triangles (which seems good). However, it also uses a total of 539 frames.

I'm aware of the excellent thread regarding both the export of max animations to .3ds files and also the stripping of animations. Particularly removing sequences that are of no use.

However, I'm curious as to whether JPCT would be up to importing the entire animation and displaying it 3 or 4 times in a scene. Since each frame would have to be exported as a separate mesh, can I expect an enormous file size and crippled heap?

Is there some way of storing in the animation in a smaller space?
Is it perhaps even possible for a proprietary JPCT format which only stores the changes involved in each vertex to reach the next keyframe? Thus allowing a reduction of heap/disk space.

Sorry for all the questions, I just want to check that it's going to do what I want before I start spending money