Jump to content

  • Log In with Google      Sign In   
  • Create Account

We're offering banner ads on our site from just $5!

1. Details HERE. 2. GDNet+ Subscriptions HERE. 3. Ad upload HERE.


#Actualfutlib

Posted 16 April 2013 - 08:15 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?


#6futlib

Posted 16 April 2013 - 08:14 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 a UI, so all I need is on-screen positioning, there is no world 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?


#5futlib

Posted 16 April 2013 - 08:14 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 a UI, so all I need is on-screen positioning, no world 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?


#4futlib

Posted 16 April 2013 - 07:59 AM

Hi,

 

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:

 

1. Use a large reference resolution (3200x1800) to position/size elements (it's a simulation game that's basically just a UI, so all I need is on-screen positioning, no world space)

2. Use large artwork, specify its size relative to the reference resolution so that it's scaled at runtime

3. Draw everything scaled down to the actual resolution (using OpenGL's glScale)

 

But I'm not sure if it's a good approach. On 1280x720, this looks pretty bad, as if there's no anti-aliasing. I guess I can figure out how to fix that with OpenGL, but I can't really imagine that this is how this is commonly being tackled. One issue I see is that I render fonts at huge sizes like 160 pt and then scale them down again. What's the common approach taken here?


#3futlib

Posted 16 April 2013 - 07:59 AM

Hi,

 

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:

 

1. Use a large reference resolution (3200x1800) to position/size elements (it's a simulation game that's basically just a UI, so all I need is on-screen positioning, no world space)

2. Use large artwork, specify its size in the reference resolution so that it's scaled at runtime

3. Draw everything scaled down to the actual resolution (using OpenGL's glScale)

 

But I'm not sure if it's a good approach. On 1280x720, this looks pretty bad, as if there's no anti-aliasing. I guess I can figure out how to fix that with OpenGL, but I can't really imagine that this is how this is commonly being tackled. One issue I see is that I render fonts at huge sizes like 160 pt and then scale them down again. What's the common approach taken here?


#2futlib

Posted 16 April 2013 - 07:58 AM

Hi,

 

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:

 

1. Use a large reference resolution (3200x1800) to position/size elements (it's a simulation game that's basically just a UI, so all I need is on-screen positioning, no world space)

2. Use large artwork

3. Draw everything scaled down to the actual resolution (using OpenGL's glScale)

 

But I'm not sure if it's a good approach. On 1280x720, this looks pretty bad, as if there's no anti-aliasing. I guess I can figure out how to fix that with OpenGL, but I can't really imagine that this is how this is commonly being tackled. One issue I see is that I render fonts at huge sizes like 160 pt and then scale them down again. What's the common approach taken here?


PARTNERS