In full screen mode, the display stretches to full screen

no-reply@allegro.cc (Alexander Zhirov) — Sun, 24 May 2020 03:08:28 +0000

Allegro display resolution 4x3. Monitor resolution 16x9. How to make the display not stretch to full screen in fullscreen mode? So that there are indents on the sides of the monitor if the formats do not match.

no-reply@allegro.cc (Edgar Reynaldo) — Sun, 24 May 2020 03:19:11 +0000

Here's some simple code I use to make an image fit within a rectangle.

#SelectExpand
  1void EagleGraphicsContext::DrawImageFit(EagleImage* img , Rectangle dest , EagleColor tint , int flags) {
 EAGLE_ASSERT(img && img->Valid() && img->Area());
  3
 
 const double hratio = dest.W() / (double)img->W();
 const double vratio = dest.H() / (double)img->H();
 const double minratio = (hratio < vratio)?hratio:vratio;
 
 const double imgw = img->W() * minratio;
 const double imgh = img->H() * minratio;
 
 Rectangle dest2(dest.CX() - imgw/2.0 ,
                 dest.CY() - imgh/2.0 ,
                 imgw ,
                 imgh
                );
 
 18//   Clipper clip(img , dest);
 
 DrawTintedStretched(img , dest2 , tint , flags);
 
 22}

The display takes whatever resolution you set it to. You have to scale / pad the image on the display yourself.

no-reply@allegro.cc (Alexander Zhirov) — Sun, 24 May 2020 03:52:50 +0000

#SelectExpand
  1struct MainScreen* scr_create_mainscreen(float factor, bool fullscreen, bool resolution, unsigned short width, unsigned short height)
  2{
  struct MainScreen* mainScreen = (struct MainScreen*)malloc(sizeof(struct MainScreen));
  show_message_error(mainScreen, "Не удалось выделить место для MainScreen");
  
  Display* display = XOpenDisplay(NULL);    
  show_message_error(display, "Не удалось открыть XDisplay");
  
  Screen* screen = XDefaultScreenOfDisplay(display);
  
  mainScreen->display = NULL;
  mainScreen->FPS = 60;
  mainScreen->full_width = screen->width;
  mainScreen->full_height = screen->height;
  
  if((float)factor >= 0.1 && (float)factor < 1.0)
      mainScreen->factor = factor;
  else if((float)factor >= 1.0)
  {
      mainScreen->fullscreen = true;
      mainScreen->factor = 1.0;
  }
  else
      mainScreen->factor = 0.5;
  
  if(resolution)
  {
      if(width >= 320)
          mainScreen->width = width;
      else
          mainScreen->width = 320;
      
      if(height >= 240)
          mainScreen->height = height;
      else
          mainScreen->height = 240;
  }
  else
  {
      mainScreen->width = mainScreen->full_width * mainScreen->factor;
      mainScreen->height = mainScreen->full_height * mainScreen->factor;
  }
  
  if(!mainScreen->fullscreen)
      mainScreen->fullscreen = fullscreen;
  
  if(mainScreen->fullscreen)
  {
      mainScreen->scale_factor_x = (float)mainScreen->full_width / mainScreen->width;
      mainScreen->scale_factor_y = (float)mainScreen->full_height / mainScreen->height;
  }
  
  XCloseDisplay(display);
  
  return mainScreen;
 56}
 57
 58void scr_free(struct MainScreen* mainScreen)
 59{
  al_destroy_display(mainScreen->display);
  free(mainScreen);
 62}
 63
 64void scr_create_display(struct MainScreen* mainScreen)
 65{
  if(mainScreen->fullscreen)
      al_set_new_display_flags(ALLEGRO_FULLSCREEN_WINDOW);
  
  mainScreen->display = al_create_display(mainScreen->width, mainScreen->height);
  show_message_error(mainScreen->display, "Не удалось инициализировать дисплей");
  
  if(mainScreen->fullscreen) // если фуллскрин
  {
      ALLEGRO_TRANSFORM t;
      al_identity_transform(&t);
      al_scale_transform(&t, mainScreen->scale_factor_x, mainScreen->scale_factor_y);
      al_use_transform(&t);
  }
 79}

I use scaling. I just don’t understand how to fit a square image into a rectangular one so that it does not stretch to the full screen. If the resolution is true, then I want to use the resolution passed by the width and height parameters. But my image is stretched to full screen and distorted. I want it to be in the center. So that in full screen there are indents on the sides.

no-reply@allegro.cc (Edgar Reynaldo) — Sun, 24 May 2020 13:37:51 +0000

Calculate the scale for the width and height and use the minimum value for your scaling.

no-reply@allegro.cc (MikiZX) — Sun, 24 May 2020 16:36:18 +0000

Possibly you need to, once the switch to fullscreen mode is made, re-create Allegro's display in the 16:9 monitor's native resolution (or at least 16:9 aspect ratio) and then draw your Allegro 4:3 content centered on the screen and scalled appropriately.
What I think might be happening now is that your 4:3 resolution (used by your Allegro program) is actually supported by your monitor and it is the monitor that does the stretching to fullscreen.
Instead of drawing directly on the Allegro display, try drawing all your Allegro game content on a bitmap (that would be 4:3 in aspect ratio - using al_set_target_bitmap https://www.allegro.cc/manual/5/al_set_target_bitmap) and then once drawing is complete simply draw this bitmap on the Allegro display as is (in case of 4:3 windowed mode) or centered and scalled in case of 16:9 native resolution full screen mode. If this explanation makes sense?

no-reply@allegro.cc (Alexander Zhirov) — Wed, 27 May 2020 02:38:08 +0000

Well, after a few days, I still implemented a mechanism for changing the resolution of the display image.

Here is a demo, and here is the source code.

P.S.Please do not swear::)

no-reply@allegro.cc (Edgar Reynaldo) — Sun, 31 May 2020 11:53:03 +0000

Why don't you just check the resolution of the monitor and set your allegro display accordingly using allegro?

#SelectExpand
  1#include "allegro5/allegro.h"
  2
  3int main(int argc , char** argv) {
  4   (void)argc;
  5   (void)argv;
  6   
  7   if (!al_init()) {return -1;}
  8   const int NMON = al_get_num_video_adapters();
  9   for (int i = 0 ; i < NMON ; ++i) {
 10      ALLEGRO_MONITOR_INFO info;
 11      al_get_monitor_info(i , &info) {
 12         printf("Adapter #%d is %d x %d at %d,%d\n" , i , info.x2 - info.x1 , info.y2 - info.y1 , info.x1 , info.y1);
 13      }
 14   }
 15
 16   return 0;
 17}

no-reply@allegro.cc (Alexander Zhirov) — Sun, 31 May 2020 14:39:36 +0000

Edgar Reynaldo said:

Why don't you just check the resolution of the monitor and set your allegro display accordingly using allegro?

Oh, how could that be? I did not even know that Allegro has its own methods of obtaining information about the monitor. I will take advantage of your offer. Thanks!:)

no-reply@allegro.cc (Edgar Reynaldo) — Mon, 01 Jun 2020 06:06:02 +0000

The docs are your friend.

https://liballeg.org/a5docs/trunk/

https://bitbucket.org/bugsquasher/unofficial-allegro-5-binaries/downloads/Allegro525.chm

no-reply@allegro.cc (Chris Katko) — Sat, 06 Jun 2020 21:10:01 +0000

It's fine to have an algorithmic solution but have you considered just using your graphics drivers to do it?

In Windows, nVidia (and 99% sure AMD) let you set the scaling mode for lower size resolutions.

For nvidia it's under Adjust Desktop Size and Position.

no-reply@allegro.cc (Niunio) — Thu, 18 Jun 2020 01:50:22 +0000

That would be a solution, Chris, but most people just don't deal with driver configuration (or even know it is possible to) and blame the game because it doesn't look nice.

My engine gets monitor resolution or the window size and the desired resolution, then creates a backbuffer with the desired resolution and scales it properly drawing in the correct position. This code calculates the size and offset while this other is the actual rendering.

no-reply@allegro.cc (Edgar Reynaldo) — Wed, 01 Jul 2020 01:46:21 +0000

To be fair, this is driver dependent behavior. Nothing allegro can do about it but adapt.