Jump to content

  • Log In with Google      Sign In   
  • Create Account

Supporting both high and low resolutions in a 2D game


Old topic!
Guest, the last post of this topic is over 60 days old and at this point you may not reply in this topic. If you wish to continue this conversation start a new topic.

  • You cannot reply to this topic
4 replies to this topic

#1 futlib   Members   -  Reputation: 197

Like
0Likes
Like

Posted 16 April 2013 - 07:48 AM

I want to support both low-end desktop resolutions (like 1024x768) and pretty large resolutions (that's 2880x1800 for the 15" Retina MBP).

 

My basic approach is this:

  • Use a large reference resolution (3200x1800) to position/size elements (it's a simulation game that's basically just GUI, so there is no world space, just screen space)
  • Use large artwork, specify its size relative to the reference resolution so that it's scaled at runtime
  • Draw everything scaled down to the actual resolution (using OpenGL's glScale)

But I'm not sure if it's a good approach. It's not a huge game, so I don't think asset size is going to be an issue, but I see some other red flags:

  1. It looks pretty scruffy on lower resolutions like 1280x720. Like as if there's no anti-aliasing. I suppose I could fix that with OpenGL, but it makes me wonder whether I should
  2. I render fonts (using FreeType) at huge sizes like 160 pt, just to scale them down again later. That wastes both memory and makes them look worse then they could. I'm thinking of not scaling fonts and instead calculating font sizes based on the difference between reference resolution and actual resolution, but that's not going to be very exact.

Is there a better approach than what I came up with?


Edited by futlib, 16 April 2013 - 08:15 AM.


Sponsor:

#2 SimonForsman   Crossbones+   -  Reputation: 6110

Like
0Likes
Like

Posted 16 April 2013 - 09:26 AM

1) Don't manually scale things with OpenGL , just use the reference resolution (adjust for the aspect ratio if you don't want to squash/stretch things when going from 4:3 to 16:9 for example) when you create your orthographic projection matrix.

 

2) Use texture filtering and mipmaps to reduce scaling artifacts.

 

3) possibly use multiple sprite sets for different resolutions (it might be a good idea to remove small details at lower resolutions)


I don't suffer from insanity, I'm enjoying every minute of it.
The voices in my head may not be real, but they have some good ideas!

#3 futlib   Members   -  Reputation: 197

Like
0Likes
Like

Posted 17 April 2013 - 12:22 AM

1) Don't manually scale things with OpenGL , just use the reference resolution (adjust for the aspect ratio if you don't want to squash/stretch things when going from 4:3 to 16:9 for example) when you create your orthographic projection matrix.

 

Fixed this, now it looks much nicer (but could still do with antialiasing).

 

However, this is kind of a hack I came up with to zoom in on all aspect ratios less narrow than 16:9. My reference resolution is 16:9, but I don't want black bars on 5:4, so I basically just zoom in until there are no bars anymore (that's at 2250x1800 for 5:4) Without the glScale hack, everything gets stretched. Any idea how to better solve this?

 

Edit: Came up with a better hack (I think): I'm adjusting the reference width for the aspect ratio, i.e. I end up with a reference size of 2250x1800 for 5:4, which I use for the ortographic projection matrix. Means I end up with a dynamic reference width, but that's fine since I can account for that in the UI code.

 

2) Use texture filtering and mipmaps to reduce scaling artifacts.

 

That's a topic I avoided until now, but I suppose I'll dig deeper into it. OpenGL seems to offer a ton of options, fortunately.

 

Anyway, rather relieved that the approach I sort of made up myself is apparently common smile.png Got any advice on the font issue? Should I just scale the damn fonts down or should I try to make FreeType render them in a different size based on e.g. the vertical resolution?


Edited by futlib, 17 April 2013 - 12:55 AM.


#4 SimonForsman   Crossbones+   -  Reputation: 6110

Like
1Likes
Like

Posted 17 April 2013 - 01:52 AM

1) Don't manually scale things with OpenGL , just use the reference resolution (adjust for the aspect ratio if you don't want to squash/stretch things when going from 4:3 to 16:9 for example) when you create your orthographic projection matrix.

 

Fixed this, now it looks much nicer (but could still do with antialiasing).

 

However, this is kind of a hack I came up with to zoom in on all aspect ratios less narrow than 16:9. My reference resolution is 16:9, but I don't want black bars on 5:4, so I basically just zoom in until there are no bars anymore (that's at 2250x1800 for 5:4) Without the glScale hack, everything gets stretched. Any idea how to better solve this?

 

 

>2) Use texture filtering and mipmaps to reduce scaling artifacts.

 

 

If you got 3200x1800 at 16:9 and switch to a 5:4 resolution and want to cut off the sides rather than stretch or add black borders you can set glOrtho to use:

 

top: 1800

bottom: 0 (or swap them depending on which way you want your y axis to go)

 

and then since we only want a 2250 region we need to cut off 950 pixels on the sides (475px per side), thus:

left: 475

right: 2725

 

so glOrtho(475.0, 2725.0, 0.0, 1800.0, 0.0, 1.0) should do the trick.

 

or more generic:

if we have:

referenceResolution.x = 3200

referenceResolution.y = 1800

referenceResolution.aspect = referenceResolution.x / referenceResolution.y // 1.7777777777778 in this case

and:

resolution_x = 1280

resolution_y = 1024

aspect = resolution_x / resolution_y // 1.25 in this case

horizontalFactor = aspect / referenceResolution.aspect //0.703125 in this case

 

then in order to not get any borders we do:

 

width = referenceResolution.x * horizontalFactor // 2250 in this case

diff = referenceResolution.x - width // 950

left = diff/2

right = left+width

 

glOrtho(left,right,0.0, 1800.0,0.0,1.0)

 

if you switch to a aspect ratio that is wider than the reference you will see objects rendered at a negative x position (if nothing is rendered at a negative horizontal position you get a border)

to get the border on the side(Which you want if nothing is really rendered there anyway) at ultra wide resolutions(horizontalFactor > 1.0) you can just render one black (or textured if you want fancy borders) quad from 0.0,bottom(0 or 1800) to left, top(1800 or 0) and one from right,bottom to referenceResolution.x, top

 

As for the fonts, if scaling with mipmaps and filtering doesn't give clear enough results you could try to generate textures based on the vertical resolution, or look at the freetype-gl library and its distance field examples (that method requires OpenGL 2.0 but the results are really great)


I don't suffer from insanity, I'm enjoying every minute of it.
The voices in my head may not be real, but they have some good ideas!

#5 futlib   Members   -  Reputation: 197

Like
0Likes
Like

Posted 17 April 2013 - 06:55 AM

Thanks, I'm quite happy with this now.

 

I'll stick to OpenGL 1.4 if I can (don't need no fancy graphics but I want to support old hardware as much as possible), I'm quite sure antialiasing will make the fonts look good enough.






Old topic!
Guest, the last post of this topic is over 60 days old and at this point you may not reply in this topic. If you wish to continue this conversation start a new topic.



PARTNERS