I have a ship, and it follows a dummy object directly in front of it. When it reaches a certain distance from the center of the world, I would like to make it turn directly towards the player's ship. For that, I would like to calculate the degree between a direction vector composed of the ship's transformed center and its dummy's transformed center and the player's ship's transformed center. How would I go about doing that?

I've written two simple methods, a turnTo which simply calculates the number of iterations (in x degree segments) that the ship will turn on its Y axis, and a turnAround which turns the number of iterations that turnTo calculated (as follows). So how do I implement turnTo()?

      protected void turnAround() { //RUNS THE TURN-AROUND LOOP FOR THE ENEMY FIGHTER
if (!turning && i == numberOfTurnSegs) {
      turning = true;
      i = 0;
}
tieFighter.rotateAxis(enemyShip.getYAxis(), (float)Math.toRadians(10));
gameInstance.moveTowards(enemyShip, tieGuide.getTransformedCenter(), .1f); //THIS MOVES IT FORWARD
i++;

if (i == numberOfTurnSegs) {
      gameInstance.moveTowardsMinusY(enemyShip, tieGuide.getTransformedCenter(), 1f); //GET IT AWAY FROM SKY SO NO MORE COLLISION
      turning = false;
      lastTurn = System.currentTimeMillis();
}
      }


What's the equivalent of the following code (your car example's camera) for a game on the X/Y plane? I tried switching the Zs and Ys around, but I get weird results. For one thing, my game is of a ship with greater maneuverability than the car and the camera  sometimes ends on opposite sides of the ship (sometimes it's under it, sometimes over it).

   private void moveCamera() {
      SimpleVector oldCamPos=camera.getPosition();
      SimpleVector oldestCamPos=new SimpleVector(oldCamPos);
      oldCamPos.scalarMul(9f);

      SimpleVector carCenter=car.getTransformedCenter();
      SimpleVector camPos=new SimpleVector(carCenter);
      SimpleVector zOffset=car.getZAxis();
      SimpleVector yOffset=new SimpleVector(0, -100, 0);
      zOffset.scalarMul(-250f);

      camPos.add(zOffset);
      camPos.add(yOffset);

      camPos.add(oldCamPos);
      camPos.scalarMul(0.1f);

      SimpleVector delta=camPos.calcSub(oldestCamPos);
      float len=delta.length();

      if (len!=0) {
         /**
          * Do a collision detection between the camera and the ground to prevent the camera from
          * moving into the ground.
          */
         theWorld.checkCameraCollisionEllipsoid(delta.normalize(), new SimpleVector(20, 20, 20), len, 3);
      }

      /**
       * And finally: Look at the car
       */
      camera.lookAt(car.getTransformedCenter());
   }


I'm trying to identify something wrong with my program and need to know what in jpct would print that message.

I've noticed that on too many video cards, billboarded planes don't work (my animated GIFs come off as black and white for some reason), with both the software or hardware renderer. Also, most of those times the Overlay with TRANSPARENCY_MODE_DEFAULT doesn't work either. Has anybody else complained?

What does this method look like with the now-existing reproject2D3DWS? I've been trying everything intuitive and it hasn't been working for me. I'm hoping, by the way, to no longer need the collision bit (so I won't need the 3D planes per screen). Thanks in advance.

     private void moveByMouse() {//WALKBYMOUSE; CALLED ONCE TO SETUP THE WALK DIRECTION
mouseWalk = true;
SimpleVector ray = Interact2D.reproject2D3D(theCamera, buffer, mouseX, mouseY);
currentRoom.plane.setVisibility(true);
if (ray != null) {
     SimpleVector norm = ray.normalize();
     Matrix mat = theCamera.getBack();
     mat = mat.invert3x3();
     norm.matMul(mat);

     SimpleVector ws = new SimpleVector(ray);
     ws.matMul(theCamera.getBack().invert3x3());
     ws.add(theCamera.getPosition());

     float f = theWorld.calcMinDistance(theCamera.getPosition(), norm, 1000);
     if (1==1/*f != Object3D.COLLISION_NONE*/) {
SimpleVector offset = new SimpleVector(norm);
norm.scalarMul(f);
norm = norm.calcSub(offset);
SimpleVector heroCenter = hero.getTransformedCenter();
SimpleVector destination = new SimpleVector(norm);
destination.x += theCamera.getPosition().x;
destination.z += theCamera.getPosition().z;
destination.y = heroCenter.y; // Make y the same as for the hero to avoid moving up/down.
hero.setRotationMatrix(destination.calcSub(heroCenter).getRotationMatrix());
target = new SimpleVector(destination);
     }
}
     }


...even after I added the premusably redundant line this.addKeyListener(keyMapper). My game loop prints "polling" just before I poll the KeyMapper, but then the state is always RELEASED (with key code 0). Very bizarre. It's worth noting that the pre-game parts of my game are handled on a canvas that I remove from the frame when the game starts. But this.addKeyListener(keyMapper) is being called AFTER the call to remove the canvas.

I'm doing picking with the mouse on objects. I'm creating the textured plane like this:
     private Object3D createPlane(String textureName) {
Texture texture = TextureManager.getInstance().getTexture(textureName);
Object3D plane = Primitives.getPlane(1, texture.getWidth()/6);
plane.setTransparency(100);
plane.setTexture(textureName);
plane.setSelectable(Object3D.MOUSE_SELECTABLE);
plane.build();
return plane;
     }

Then I'm trying to get 2D bounds as follows:
     public Rectangle getBounds2D(Camera theCamera, FrameBuffer buffer) {
if (sourceMesh == null) {
     VertexController controller = new VertexController(this.unitPlane.getMesh());
     sourceMesh = controller.getSourceMesh();
}
SimpleVector p1 = new SimpleVector(sourceMesh[0]), p2 = new SimpleVector(sourceMesh[1]);
SimpleVector p3 = new SimpleVector(sourceMesh[2]), p4 = new SimpleVector(sourceMesh[3]);
p1.matMul(unitPlane.getWorldTransformation());p2.matMul(unitPlane.getWorldTransformation());
p3.matMul(unitPlane.getWorldTransformation());p4.matMul(unitPlane.getWorldTransformation());
p1 = Interact2D.project3D2D(theCamera, buffer, p1);
p2 = Interact2D.project3D2D(theCamera, buffer, p2);
p3 = Interact2D.project3D2D(theCamera, buffer, p3);
p4 = Interact2D.project3D2D(theCamera, buffer, p4);
float x1 = p1.x, x2, y1 = p1.y, y2;
if (x1 != p2.x)
     x2 = p2.x;
else x2 = p3.x;
if (y1 != p2.y)
     y2 = p2.y;
else y2 = p3.y;
System.out.println("X: "+x1 +" Y: "+y1 +" WIDTH : "+((int)Math.abs(x1-x2)) +" HEIGHT: "+(int)Math.abs(y1-y2));
return new Rectangle((int)x1, (int)y1, (int)Math.abs(x1-x2), (int)Math.abs(y1-y2));
     }

The trouble is that only the same two planes are selectable (the others aren't) and x1 is often negative (and it's always the right values for the same two).

I should add that I've rotated all the objects (but not the camera) by -90 degrees around the X axis so that I'm looking down on them from above (the world is on the X/Y plane).

A method on World or FrameBuffer or so which you could call before draw() (or maybe a drawWithAxis() or something of the sort) that drew this:


That would be REALLY helpful.