Hi there,

I have a level of tiles, and a main character. The camera and main character move to a tile when the user touches it. Here is the code I am using to implement this (which is inside my onDrawFrame() method):

/**
* CAMERA MOVEMENT
*
* This first section of code is part of the algorithm which handles
* camera movement. When a touch event occurs, the origin of the tile which
* was selected is saved as the destinationX and destinationZ
* properties. The following code animates moving the camera from its
* existing position to this destination. */

// To animate smoothly (frame rate independent) we're going to keep
// track of how much time elapses between frames. We need a calendar
// object to do this.
Calendar now = Calendar.getInstance();

// Calculate how much time has passed since the previously rendered frame.
long millisecondsPassed = now.getTimeInMillis() - previousFrameTime;

// If the camera isn't already approximately at the destination...
if ( cameraX < destinationX-1 || cameraX > destinationX+1)
{
// The xModifier is a variable which is +1 if the destination is down
// the positive x axis and -1 if it is down the negative.
Float xModifier = 1f;

// If the destination is down the -x axis, change the xModifier accordingly.
if ( cameraX > destinationX )
{
xModifier = -1f;
}

// Set the camera's new position. The xModifier determines if it
// will be down the +x or -x direction, and the millisecondsPassed
// makes this frame rate independent - so on a slow device the
// animation will be blocky but fast, and on a fast device the
// animation will be smooth and fast.
cameraX = cameraX + (0.01f * xModifier * millisecondsPassed);

// Translate the AntQueen object
antQueen.translate((0.01f * xModifier * millisecondsPassed), 0, 0);
}

// This block of code does exactly the same as the x-direction code
// above but for the z-direction.
if ( cameraZ < destinationZ-1 || cameraZ > destinationZ+1)
{
Float zModifier = 1f;

if ( cameraZ > destinationZ )
{
zModifier = -1f;
}

cameraZ = cameraZ + (0.01f * zModifier * millisecondsPassed);

// Translate the AntQueen object
antQueen.translate(0, 0, (0.01f * zModifier * millisecondsPassed));
}

// Record the current time for the next call to this method (the next
// frame).
previousFrameTime = now.getTimeInMillis();

// Move the camera to its new position. The -10 is a constant offset
// on the z axis.
camera.setPosition(cameraX,cameraY,cameraZ-10);

My problem is that if the camera and queen are moving when I flip the camera over (and it re-adjusts for landscape or portrait) the queen will often teleport out of sync with the camera. Normally she is meant to sit in the centre of the camera, so the camera is essentially locked on to the top of her head.

I'm trying to work out why. All of my creation code is in my onSurfaceCreated() method, and the only thing inside onSurfaceChanged() is:

public void onSurfaceChanged(GL10 gl, int w, int h)
{
// Checks if there is an existing FrameBuffer and disposes it if required.
if (frameBuffer != null)
{
frameBuffer.dispose();
}

frameBuffer = new FrameBuffer(gl, w, h);
}

I know I haven't provided a lot of information and I'm finding it hard to describe my problem, but in-case someone recognizes the issue and has dealt with it before I thought it was worth a shot posting this.

I will try and post some better information as I work through it myself.

Hi Egon,

Will have a look at the OBJ format and see if it has pivots and if so will provide you a test case.

We found a solution just now - he imported our OBJ files into Max, exported them as 3DS, and doing this has stripped out all the transformation information which was causing them to get messed up before.

So no urgency on the OBJ pivots!

Thanks for your patience.

I've been following this thread and still don't understand what it means to scale around an arbitrary point? Are you talking about distorting the original model in any way? Or simple scaling it (around the centre) and translating it to accommodate this point?

By distortion I mean something like (see attached image)

[attachment deleted by admin]

I don't think you're after code examples - it sounds more like you want to understand how it works. However, just in case it is helpful here is how I implemented picking. I am using picking so that the player can select tiles within my game (laid out along the xz plane).

    public boolean onTouchEvent(MotionEvent event)
    {
    // Find the x and y positon of the touch event
    Integer xpos = new Float(event.getX()).intValue();
    Integer ypos = new Float(event.getY()).intValue();
   
    // Log the position
    Log.d("xpos", xpos.toString());
            Log.d("ypos", ypos.toString());
       
            // Find the direction vector that the camera is looking in and use that to find a vector
            // out from where the user has touched the screen.
SimpleVector dir=Interact2D.reproject2D3DWS(camera, frameBuffer, xpos, ypos).normalize();

    // Find the nearest object along that vector. res[0] is the distance, res[1] is the Object3D
    // which is null when there is no object.
    Object[] res=world.calcMinDistanceAndObject3D(camera.getPosition(), dir, 10000 /*or whatever*/);

    Log.d("distance", res[0].toString());

    if ( (Float) res[0] < 1000.0f )
    {
    Log.d("object", res[1].toString());

Object3D currentTile = (Object3D) res[1];

Log.d("Current Tile Centre X", new Float(currentTile.getTransformedCenter().x).toString());
Log.d("Current Tile Centre Y", new Float(currentTile.getTransformedCenter().y).toString());
Log.d("Current Tile Centre Z", new Float(currentTile.getTransformedCenter().z).toString());

// Save the x and z coordinates of the tile selected for future use.
destinationX = currentTile.getTransformedCenter().x;
destinationZ = currentTile.getTransformedCenter().z;

// TODO: Need to save the selected object in here if there is one?
    }

    touchEvent = true;

            return true;
    }

And of course any object you want to pick needs to have collision detection enabled:

// Sets the tile up so that collision events can occur so that it can be
// selected by the player.
honeyTile.setCollisionMode(Object3D.COLLISION_CHECK_OTHERS);

Like I said, I don't understand the intricacies of how it works, only that it does.

Hi all,

I load, rotate, and translate a bunch of objects in my onSurfaceChanged() method (will change this to onSurfaceCreated()) and I'm trying to understand the effect that translations made in one place have on subsequent calls to translate().

For example, in the following code, will object2's initial position be impacted by the translation of object1?

(note the loadOBJModel method is a custom one I wrote as a shortcut to the model/texture loading process)

object1 = new Object3D(loadOBJModel(MODEL_1, TEXTURE_NAME_1));

object1.translate(-5.0f,0.0f,-5.0f);

object2 = new Object3D(loadOBJModel(MODEL_2, TEXTURE_NAME_2));

object2.translate(5.0f,.0f,5.0f);


Furthermore, when I am using rotations and translations, is there an order I should be doing these?

This feels like graphics programming 101. I've written Open GL / GLU / GLUT code in C++ before and not been so confused because I could use GL_START and GL_END tags to start and stop each transformation (I think that's what they were called).

IF the answer to the above questions are yes, translate() is impacted by the previously translated position... What is an easy way to translate an Object3D to a particular point in world space?

I too found it a little frustrating at first - but the reality is that modelling programs like 3DS Max have the +z axis pointing up as Egon mentioned before, so translating between different co-ordinate systems is just part of the business.

If you do have objects which exist in the +y up co-ordinate system you can rotate every object by PI / -2.0 along the X axis (Object3D.rotateX()) as you import it then it adjust it correctly (that's what I've been doing). This, of course, relies on object origins being in the "centre" of each object and only really makes sense if you're importing model files.

I've been working with a 3D modeler on a project using JPCT-AE and one of the things he's told me is that you should never have 3D polygons up against each other. You should design the models so that only what is visible has a face - and even the opposite side of the visible sides are not rendered. It's for performance reasons and also because of the weird behaviour when two faces exist in the same space (jaggies etc).

If you want to make a wall, make one big polygon and use textures to give it a brick look. And if you never see the flip side of it, just make it a 2D plane.

I have a character in my game who sits in the middle of a 5x5 grid of tiles. Aesthetically she has a front (where she is looking).

When I click on one of the tiles, I want my character to look at the centre of that tile.

I've currently spent 6 hours or more trying to work this out but I'm failing miserably. I will describe my approach below, but if there is an easier way or a way JPCT-AE can assist me in doing this, that would be great.

My approach:

My character is called the Queen. I've set up a property which is a SimpleVector which represents the direction the Queen is looking. At first she is looking away from the camera so this Vector is set to (0,0,1).

private SimpleVector queenDirection;

And the initialization of the initial direction:

public void onSurfaceCreated(GL10 gl, EGLConfig config)
{
// The Queen is originally facing to 0 degrees.
queenDirection = new SimpleVector(0f,0f,1f);
...

My algorithm is:

- Calculate a vector from the Queen's current position (0,0,0 for now in world space) to the centre of the tile selected. I use the formula vector = destinationX-currentX, destinationY-currentY, destinationZ-currentZ

SimpleVector eyeline = new SimpleVector(
destinationX - queen.getTransformedCenter().x,
0,
destinationZ - queen.getTransformedCenter().z).normalize();

- Then I calculate the angle (in radians) between the Queen's current viewing direction, and this new vector using the formula angle = acos((v1 DOT v2) / (v1.length * v2.length)):

float dotProduct = queenDirection.calcDot(eyeline);

Double temp = (double)  dotProduct / ( queenDirection.length() * eyeline.length());

double angle = Math.acos(temp)

... but already I run into problems because (perhaps due to the accuracy of float/double or something else) the dotProduct and therefore "temp" variable which is passed into the arc cosine function is sometimes either slightly higher than 1 (1.00000123) or it's negative - either way the acos function returns NaN because it only accepts parameters between 0 and 1.

The code which actually does the rotation is:

if ( angle > 0.5 )
{
queen.rotateY((float) angle);

queenDirection.x = eyeline.x;
queenDirection.z = eyeline.z;
}

I'm not great at mathematics, but I'll get stuck into if it I have to. My primary question is whether there is an easier way? If not, I'll keep working at this but I wanted to check before I spend another 6 hours at it.

This game is going to have a lot of models who need to turn and face each other often, so I need to have this down before I move on.