Question

I’m building a game in OpenGL ES 1 that involves a terrain map shown in perspective. I want to draw some sprites on the map that scale with distance. I’m able to draw sprites, but they’re always the same size no matter how far away they are from the camera.

I believe I could dynamically calculate the size based on the distance from the camera, the viewport width, etc., but I’d much prefer having the size calculated automatically.

Here’s my code:

   GLfloat quadratic[] =  { 1.0f, 0.0f, 0.0f };
   glPointParameterfv(GL_POINT_DISTANCE_ATTENUATION, quadratic);
   glPointSize(40);
   glPointParameterf(GL_POINT_SIZE_MAX, maxSize);
   glPointParameterf(GL_POINT_SIZE_MIN, 1.0f);
   glTexEnvf(GL_POINT_SPRITE_OES, GL_COORD_REPLACE_OES, GL_TRUE);
   glEnable(GL_POINT_SPRITE_OES);

   GLfloat point_array[] = 
   {
      territoryOrigin.x, territoryOrigin.y, 10.0,
   };
   glVertexPointer(3, GL_FLOAT, 0, point_array);
   glDrawArrays(GL_POINTS, 0, 1);

   glTexEnvi(GL_POINT_SPRITE_OES, GL_COORD_REPLACE_OES, GL_FALSE);
   glDisable(GL_POINT_SPRITE_OES);

Answer 1

Ok, I figured this out. Basically I drew quads that act like ‘pop-up’ cutouts where the angle of the pop-up is determined by the current viewing rotation. Then I disable the depth test when performing the drawing so they don’t cut into the 3D terrain they’re drawn on. The benefit of this approach is I don’t need to calculate a scale value – it’s taken care of because I’m drawing regular quads in a perspective viewport.

First, I need to determine the viewing angle on a scale from 0 (overhead) to pi/2 (ground-level). I do that with this equation:

viewingAngle = (currentRotation / 90.0) * M_PI_2;

currentRotation is simply the angle I’m using in glRotatef. Given the viewing angle, I can calculate the vertical height and depth of the ‘pop-up’ edge of the quad. Basically, it’s simple trigonometry from here. Imagine looking at the pop-up cutout from the side. It has a fixed base, and it has an edge that raises from a horizontal position to a vertical position. This edge traces the outline of a circle quadrant. And at any given point, it forms a right triangle you can use to calculate position values.

If you know the angle (as seen in the snippet above) and the hypotenuse (which in this case is the y-height of the pop-up image texture as if it were laying flat) then you can solve for the opposide side of the triangel by multiplying the sin of the angle times the hypotenuse. This value corresponds to the depth at which the pop-up edge must be lifted off the ground. Since sin(angle) = opposite/hypotenuse, I can solve for ‘opposite’ as such:

popUpValueZ = sinf(viewingAngle) * imageHeight;

Next, I needed to calculate the y-size of the pop-up image. In the imaginary triangle above, this corresponds to the side adjacent to the pop-up angle. As such, cosine is used to calculate its value:

popUpValueY = cosf(viewingAngle) * imageHeight;

Now I can use popUpValueY and popUpValueZ to determine my vertices. They will act as the height and depth of my quad, respectively. As the viewing angle gets lower to the ground, the Z value increases off the ground and the Y value gets shorter and shorter, so that it begins to resemble a vertical plane instead of a horizontal one.

The other thing I had to do:

glDisable(GL_DEPTH_TEST);

I found that these pop-up ‘pseudo-sprites’ were fighting with the 3D terrain, so I simply disabled the depth test before drawing them. This way, they scale exactly as they should based on their position within the perspective viewport, but they always appear on top of anything drawn earlier than them. In my particular case I do want these sprites to be occluded by terrain drawn in front of it, so I just re-enabled depth testing when drawing the closer terrain.