what is video game optimisation and how does it get done well or badly?
In: 6
large software projects like video games are broken down into pieces and completed in stages. at a certain point, all of the pieces are functional and if you put them together, it works! but maybe it doesn’t work very well. maybe if you change the order of some of the instructions, and changed the way this other piece is done, it will work better. this is optimization, taking something that works and getting it to work better.
Video game optimization is the process of making a game run faster, more smoothly, have higher stability, or take up less memory for a given system running it without significantly impacting the user experience (like if you removed all effects) by increasing code efficiency or cutting back on processing-heavy aspects that the player is unlikely or unable to see. It can also refer to prioritizing processing power when the system can’t handle everything at maximum. Some examples are:
Making objects disappear if the player cannot see them, removing the requirement of loading and displaying them. They can also lower the frame rate or texture detail for objects that are distant and less able to be closely examined.
Using more efficient coding algorithms for the same task. Different approaches to coding things can have wildly different processing times because the coding languages in use are better at doing some operations than others.
Using less complex visual effects when other demands on the system are high to prioritize FPS or stability.
Using higher quality compression algorithms to make the installation download take less space.
A game with very good optimization can perform much better on the same system than a game with bad optimization, even if the first game is much more impressive visually. It’s a sliding scale, meaning that no game is perfectly optimized, and no game is perfectly unoptimized.
you can regard it as optimalisation of any fabrication process. if the computer was human, you can give him only so much work that he can handle. if you give him more, he will work slowly and stutter, maybe even refuse to communicate how busy he is.
inexperienced/lazy/notgivinglefffuuu programmers give the computer too much work. optimalization is a process where you identify the work that can not be done, or that can be done in parallel or reduce other resources usage (like memory). and then you change code correspondingly.
there are lot of means to do that: threads, vectorization, change of algorithm, numeric approximations, better usage of cache, smaller memory footprint… anything to give a break to the overworked guy
basically: + – × is cheap, everything else is expensive ( / sin cos sqrt..) to very expensive (memory allocation, access). you try to be as frugal as you can be.
Optimization is a huge topic, and there are many parts to it. You also often need to optimize to target specific aspects, such as frame time, loading time, disk space, memory, or quality, given that its common that optimizing for one often comes at the expense of others. The process of optimizing is also commonly split across disciplines: an artist might produce inefficient work, a programmer might write code that is not efficient, or a designer may want to do something that just cannot be done efficiently.
Optimizing for frame time generally means either reducing the amount of work being done or doing that work more efficiently. Reducing the work includes having artists redo parts of their work to reduce its complexity. Its easy for an artist to get hyper fixated on a single task, forgetting that the character’s ring is going to be tiny on the screen – an optimization here would be to have the artist redo the ring to be simpler. Programmers might write their code to do the same calculation multiple times, when the result could instead be saved and reused. Designers might want to have a set of mirrors in a room, but reflections prove to be too expensive to render, requiring the room to be redesigned to have fewer, or no, mirrors.
Another major form of frame time optimization is to multi-thread the game, allowing multiple calculations to run at the same time. Such optimization is generally very complicated and comes with the risk of race conditions, where the order in which the calculations occur affects the result.
Optimizing for disk space generally means adjusting compression algorithms or removing duplication of data. Generally, such optimizations come at the cost of increasing loading time.
Optimizations for loading time generally involve arranging data on the disk to make it faster to load, or require less calculations to convert its format. Both are likely to result in the game taking more disk space.
Good optimization takes a lot of development time and is a very complex thing to pull off. Additionally, you can always keep optimizing a product, so you have to stop at some point when its “good enough”. Of course, “good enough” is extremely subjective.
There are also major complexities, especially when making a PC game, as what works well on one set of hardware may be worse on another, as well as what else the user might be doing at the same time may affect what optimizations are best. Consider if I have a really powerful graphics card (GPU), but a fairly weak CPU – moving work from the CPU to the GPU is probably a good idea. However, if you have a weak GPU but a powerful CPU, that same optimization may have a worse outcome for you.
Imagine you’re playing a game of hide-and-seek with your friends in a big house. When you first start playing, it takes you a while to find your friends because you’re not sure where they’re hiding. But as you play more and more, you start to learn the layout of the house and you get better at finding your friends quickly.
Similarly, when a game developer is first making a game, it might not run very well on a person’s device. But the developer can make the game run better by “learning the layout” of the device and figuring out ways to make the game work better with it.
Here are a few examples of how a developer might optimize a game to make it run better:
Reducing the number of objects on the screen at once: Imagine your friends are hiding behind furniture in the house. If there is a lot of furniture, it might take you longer to find them. In the same way, if a game has a lot of objects on the screen at once, it can slow down the device. A developer might reduce the number of objects to make the game run faster.
Using less memory: Imagine you have a small basket to carry around while you’re playing hide-and-seek. If you fill the basket with too many things, you won’t be able to move as quickly. In the same way, if a game uses too much memory on a device, it can slow down the device. A developer might make the game use less memory so it can run faster.
Using less processing power: Imagine you’re playing hide-and-seek in a big house with lots of rooms. If you’re running around trying to open every door to see if your friends are hiding behind it, you’ll get tired quickly. In the same way, if a game is using too much processing power, it can slow down the device. A developer might make the game use less processing power so it can run faster.
By making these changes, the developer can make the game run better on a person’s device, just like you can get better at finding your friends quickly by learning the layout of the house.
Games are Software.
When making software, you use API (Application Programming Interface).
API’s are like waiters in a restaurant.
* You tell them what you want (Input)
* They process your order (Operation)
* They bring you the items you ordered (Output)
You don’t know how the Operation is done, you only know the Inputs and Output. If you’re a restaurant owner or a chef, you probably have an idea how the operation works, but you can only guess unless you have access to the kitchen.
Not all items in the menu can be done quickly, not all restaurants have the same speed and quality to delivery the items. If you want the perfect food, you do it yourself according to your own liking (Specification). But now think about it, you can create the perfect food, but can you scale it? Can you produce the perfect item on demand? Another problem, you perfected one food, but how about something else?
Restaurants can try optimize their Operations to have maximum quality and speed, but surely, you know that they can easily mess it up from some simple mistake. The more you optimize the system, the less resilient it becomes to Special Cases (bugs and glitches).
Games and Software are built on top of APIs on top APIs on top of other APIs, like a restaurant cooking for another restaurant to be served to another restaurant, and so on.
Sometimes, developers want to make their own APIs so that they know the Operation is doing exactly as per specification. The problem is you can’t get good at everything. So you go back to step 1 and just use an API that you have very high confidence that it does one and only one thing really really well.
For those engineers who really want to build their own APIs so that it can be well “optimized”, it’s futile to optimize while protecting from every case of bugs and glitch that can happen in the app. So they have to compromise, and a lot of times, the compromise is not to optimize but to make the app resilient instead.
So sometimes, optimization does not mean speed of output, but rather making consistent predictable high quality outputs. It’s better to output 5 dishes per 10 mins than 10 dishes per 5 mins but all the dishes are disgustingly bad and the kitchen is burning.
If you have to pick up all your toys and clean your room at once you get overwhelmed. You’ll get tired and take a nap. But if you plan it out and do one thing at a time in an organized way you’ll be able to get through it in no time!
It’s complex. Here’s an example for graphics optimization.
Minecraft divides most things into blocks. The computer has to calculate what each block looks like and then it draws that. Drawing each block would be very simple but the vast, vast majority of blocks on the screen can’t be seen by the player so it’s pointless to do and would waste a ton of GPU time. The optimization here is using the player camera to figure out which blocks can be seen. Then you only draw the blocks that can be seen. The rest still exist. The computer is still tracking them. They just don’t need any graphics yet. This cuts down your drawn blocks from like 10s of thousands to maybe a thousand or less.
Latest Answers