OpenGL 2D Depth Perception

Question

I have a 2D RPG game written in Java using LWJGL. All works fine, but at the moment I'm having trouble deciding what the best way to do depth perception is. So , for example, if the player goes in front of the tree/enemy (lower than the objects y-coordinate) then show the player in front), if the player goes behind the tree/enemy (higher than the objects specific y-coordinate), then show the player behind the object.

I have tried writing a block of code to deal with this, and it works quite well for the trees, but not for the enemies yet. Is there a simpler way of doing this in LWJGL that I'm missing?

Answer 1

I gather you are making an isometric 2D game? You could draw the background first, then sort all sprites (player, enemies, trees) by Y-coordinate and draw them in back-to-front order.

Answer 2

This is very similar to Eric's answer; just elaborated a bit more.

Firstly you should draw your background (graphics that do not obscure anything) first - so as an example this would be your grass, plants, sand etc.

Next you take your foreground (graphics that do obscure) in addition to your entities (player, enemies, etc.) and draw them from the top of the screen downwards. To do this you would essentially sort them according to their Y co-ordinate and then draw them from least to biggest.

In addition I would give each tile/entity a YRenderOffset field (that does not participate in the sorting) that would allow you to, for example, play havoc with the 'darkness' of a door so that it seems as though your character is walking through it: in this specific case the 'darkness' sprite would be physically located above where it appears (basically behind the house) with a YRenderOffset that corrects it back to where it should appear when rendered. You could invert this concept entirely by instead having a field called YSortOffset that would participate in the sorting and not the rendering.

The above two paragraphs can be rendered by the same code entirely. This gives rise to the concept of layers: so you would have the background and foreground layers and they would be rendered exactly the same way. You would then be able to add additional layers at some point in the future (a cloud layer?).

Answer 3

Correct me if I'm wrong, but the gist of your drawing routine is:

public void draw_frame() {
  draw_world();
  draw_character();
  draw_enemies();
}

You will need to make it a bit more sophistocated.

Two approaches come to mind:

(1) make everything drawable in your world a subclass of some base class DrawableThing, say. Give it x, y and z accessors. use z to set the height of the thing. To draw a frame, collect all of the drawable things into a great big array, sort the array by, say, z then y, and then draw them in order. Sorting in Y ensures that (I am assuming you a are using a sort of semi-overhead look like the style of games of the SNES era) when thing A is on the same "level" (z) as thing B but is above it (y), thing B probably needs to be drawn on top of thing A as it will overlap it in the view.

This could result in a big array to sort with a lot of objects, so if you can, group some of the objects together into chunks (the flat ground is a good candidate) that can be drawn in one go.

(2) Use opengl to draw in quasi-3d and let the GL take care of the layering for you: set up an isometric perspective projection that makes your world look the way you want it to, then turn on depth testing and draw everything with a Z coordinate for how high it should be. It may need to be tweaked a bit for certain objects depending on how you model your sprites/images, but it will work.