graphics_mode.h

/* ScummVM - Graphic Adventure Engine
 *
 * ScummVM is the legal property of its developers, whose names
 * are too numerous to list here. Please refer to the COPYRIGHT
 * file distributed with this source distribution.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */
 
#ifndef AGS_ENGINE_MAIN_GRAPHICS_MODE_H
#define AGS_ENGINE_MAIN_GRAPHICS_MODE_H
 
#include "ags/engine/gfx/gfx_defines.h"
#include "ags/shared/util/geometry.h"
#include "ags/shared/util/scaling.h"
#include "ags/shared/util/string.h"
 
namespace AGS3 {
 
using AGS::Shared::String;
using AGS::Engine::GraphicResolution;
using AGS::Engine::DisplayMode;
using AGS::Engine::WindowMode;
 
Size get_desktop_size();
 
namespace AGS {
namespace Engine {
class IGfxModeList;
} // namespace Engine
} // namespace AGS
 
bool find_nearest_supported_mode(const AGS::Engine::IGfxModeList &modes, const Size &wanted_size,
                                 const int color_depth, const Size *ratio_reference, const Size *upper_bound,
                                 AGS::Engine::DisplayMode &dm, int *mode_index = nullptr);
 
// Filter configuration
struct GfxFilterSetup {
    String ID;          // internal filter ID
    String UserRequest; // filter name, requested by user
};
 
// Defines how game frame is scaled inside a larger window
enum FrameScaleDef {
    kFrame_Undefined = -1,
    kFrame_Round,        // max round (integer) scaling factor
    kFrame_Stretch,      // resize to maximal possible inside the display box
    kFrame_Proportional, // same as stretch, but keep game's aspect ratio
    kNumFrameScaleDef
};
 
// Configuration that is used to determine the size and style of the window
struct WindowSetup
{
    AGS3::Size           Size;      // explicit screen metrics
    int                  Scale = 0; // explicit game scale factor
    WindowMode           Mode = AGS::Engine::kWnd_Windowed; // window mode
 
    WindowSetup() = default;
    WindowSetup(const AGS3::Size &sz, WindowMode mode = AGS::Engine::kWnd_Windowed)
        : Size(sz), Scale(0), Mode(mode) {}
    WindowSetup(int scale, WindowMode mode = AGS::Engine::kWnd_Windowed)
        : Scale(scale), Mode(mode) {}
    WindowSetup(WindowMode mode) : Scale(0), Mode(mode) {}
};
 
// Additional parameters for the display mode setup
struct DisplaySetupEx {
    int                  RefreshRate = 0;  // gfx mode refresh rate
    bool                 VSync = false;    // vertical sync
};
 
// Full graphics configuration, contains graphics driver selection,
// alternate settings for windowed and fullscreen modes and gfx filter setup.
struct DisplayModeSetup {
    String               DriverID;      // graphics driver ID
 
    // Definitions for the fullscreen and windowed modes and scaling methods.
    // When the initial display mode is set, corresponding scaling method from this pair is used.
    // The second method is meant to be saved and used if display mode is switched at runtime.
    WindowSetup          FsSetup;       // definition of the fullscreen mode
    WindowSetup          WinSetup;      // definition of the windowed mode
    FrameScaleDef        FsGameFrame =  // how the game frame should be scaled/positioned in fullscreen mode
        kFrame_Undefined;
    FrameScaleDef        WinGameFrame = // how the game frame should be scaled/positioned in windowed mode
        kFrame_Undefined;
 
    bool                 Windowed = false; // initial mode
    DisplaySetupEx       Params;
 
    GfxFilterSetup       Filter;        // graphics filter definition
};
 
// Display mode color depth variants suggested for the use
struct ColorDepthOption {
    int     Bits;   // color depth value in bits
    bool    Forced; // whether the depth should be forced, or driver's recommendation used
 
    ColorDepthOption() : Bits(0), Forced(false) {
    }
    ColorDepthOption(int bits, bool forced = false) : Bits(bits), Forced(forced) {
    }
};
 
// ActiveDisplaySetting struct merges DisplayMode and FrameScaleDef,
// which is useful if you need to save active settings and reapply them later.
struct ActiveDisplaySetting {
    DisplayMode   Dm;
    FrameScaleDef Frame = kFrame_Undefined;
    int           DisplayIndex = -1;
};
 
// Initializes any possible gfx mode, using user config as a recommendation;
// may try all available renderers and modes before succeeding (or failing)
bool graphics_mode_init_any(const GraphicResolution &game_res, const DisplayModeSetup &setup, const ColorDepthOption &color_depth);
// Return last saved display mode of the given kind
ActiveDisplaySetting graphics_mode_get_last_setting(bool windowed);
// Creates graphics driver of given id
bool graphics_mode_create_renderer(const String &driver_id);
// Try to find and initialize compatible display mode as close to given setup as possible
bool graphics_mode_set_dm_any(const Size &game_size, const WindowSetup &ws,
    const ColorDepthOption &color_depth,
    const FrameScaleDef frame, const DisplaySetupEx &params);
// Set the display mode with given parameters
bool graphics_mode_set_dm(const AGS::Engine::DisplayMode &dm);
// Set the native image size
bool graphics_mode_set_native_res(const GraphicResolution &native_res);
// Get current render frame setup
FrameScaleDef graphics_mode_get_render_frame();
// Set the render frame position inside the window
bool graphics_mode_set_render_frame(const FrameScaleDef &frame_setup);
// Set requested graphics filter, or default filter if the requested one failed
bool graphics_mode_set_filter_any(const GfxFilterSetup &setup);
// Set the scaling filter with given ID
bool graphics_mode_set_filter(const String &filter_id);
// Update graphic renderer and render frame when window size changes
void graphics_mode_on_window_changed(const Size &sz);
// Releases current graphic mode and shuts down renderer
void graphics_mode_shutdown();
 
} // namespace AGS3
 
#endif