0
\$\begingroup\$

Often times PC games offer an elaborate settings page which lets you turn 20 different knobs. Users can modify these settings at will in the pursuit of performance, or conversely, visual quality.

But, the first time you launch the game, how does it know what settings to apply? I'm guessing there is something smarter going on than just using the 'MEDIUM' configuration for everything, and then letting the user figure out the right configuration...

In fact, I'd further guess that settings are chosen on first launch in the interest of performance, i.e. the game will choose the correct settings for this particular machine so it can run at 60 FPS and not crash from out of memory... So, if there is indeed a runtime algorithm employed that selects the appropriate settings, what kind of heuristics are used to choose those settings?

  • Is there a database of devices, or hardware components, that can be used to determine the correct performance of a device? (I assume not.)

  • Is there a scoring system based on the various specs of system components: system memory size, D3D feature level, GPU memory, etc... This seems more believable, but I'd like to know if there are examples of this being done.

And, there are other strategies that I'm not interested in, e.g. doing a mini profiling run and then determining the correct settings based on framerate of that run. Or, dynamically tuning the performance on the fly, e.g. detect the framerate is dropping, and then somehow degrade the quality to improve.

Both of those approaches aren't what I'm after. I'm looking for some heuristics to employ when the game launches, and I'd like those heuristics to be able to spit out some sort of performance criteria for the device so I can know what settings to run my game at.

If I get it wrong, the user can always go back and turn the knobs in the settings page, but I'd like to do most of the work for them!

\$\endgroup\$
4
\$\begingroup\$

Basically, there will be a mapping from graphics performance level setting (low/medium/high/et cetera) to particular values of a variety of internal knobs and dials in the underlying graphics engine. It can affect almost anything: texture sizes, maximum LOD level, multisample passes, toggling entire features (such as reflection) that often require extensive extra GPU resources, and so on. It is not a fixed list of features and will vary from game to game or engine to engine.

Usually these mappings will be decided experimentally or via simple algorithms based entirely on the range of hardware (from the minimum spec upwards) the game is expected to ship on.

Sometimes studios will amass a database of particular GPU versions and bugs or hidden issues with those GPU and/or related drivers that they will use to toggle features behind-the-scenes as well (although this practice was far more common in the earlier days of GPUs, where graphics APIs were much younger and there was much less standardization across the hardware).

There is no general solution for the heuristics you're looking for. It depends on the demands and needs of your game. But you're right that most PC games tend to run a basic hardware check to "auto-detect" the appropriate settings. You can implement this relatively easily yourself once you've established what your game's performance breakpoints will be.

Both major graphics APIs offer ways to query their support for particular features -- for example, whether or not they support particular kinds of multisampling, or how many extra render targets you could make. Many settings can be "auto-detected" simply by creating a graphics device and asking the API directly.

For all the rest, you can simply probe them experimentally (for example, try to allocate textures of the maximum size you want for your highest setting; if it fails, fall back to lower setting breakpoints until you succeed).

\$\endgroup\$

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.