shadownsa.blogg.se

1. INCREASE OPENGL RESOLUTION MODO 801 DRIVER
2. INCREASE OPENGL RESOLUTION MODO 801 CODE
3. INCREASE OPENGL RESOLUTION MODO 801 PC

An FPS of 200 means the frame time is 0.005 seconds. So if the FPS is 25, the frame time is 1/25 = 0.04 seconds. It is better to measure frame time, which is the inverse of the FPS (conversely, FPS is the inverse of frame time). FPS is not always the best way to measure performance because it is not linear in the time domain. This is considered as rendering speed by most gamers and new programmers. It is common for people to measure FPS (Frames Per Second, sometimes called Frame Rate). However, if you have (say) a 60Hz monitor and your times all come out at either 16.66ms, 33.33ms or 50ms then suspect that you have a problem.

INCREASE OPENGL RESOLUTION MODO 801 PC

However, most PC graphics adaptors do not do this by default - so you would probably have to have taken an active step to turn this feature on.

INCREASE OPENGL RESOLUTION MODO 801 CODE

You can then adjust one piece of the code at a time, remeasure and get a reasonable idea of the practical improvements you are getting as a result of your optimisation efforts.Įven when you do this, you may have to take a little care - some systems force the swapbuffers command to wait for the next video vertical retrace before performing the swap - if that is the case then you'll only ever see times that are an exact multiple of the video frame time and it will be impossible to see exactly how much time you are consuming.

The best practical solution is to measure the time between consecutive returns from the swapbuffer command with your entire application running.

Graphics cards are quite complex parallel systems and it's exceedingly hard to measure precisely what's going on. If you measure the time it takes to draw 1000 triangles (with a glFinish in front and behind), you'll probably be happy to discover that it doesn't take twice as long to draw 2000 of them. However, eliminating these overlaps in time can also be misleading. The cure for this is to put a 'glFinish' call before you start the clock as well as just before you stop the clock. Even a 'swapbuffer' call can leave work for the graphics system to do that can hang around and slow down subsequent operations in a mysterious fashion. Worse still, there is the possibility that when you started drawing polygons, the graphics card was already busy because of something you did earlier. That works to a degree - but experience suggests that not all implementations have literally completed processing by then. It is wise to use a 'glFinish' command between drawing the polygons and stopping the clock - this theoretically forces all of the rendering to be completed before it returns - so you get an accurate idea of how long the rendering took. Hence, measuring the time it took to pass the polygons to OpenGL tells you very little about performance. Sometime later, the graphics processor picks up the data from the FIFO and draws it.

INCREASE OPENGL RESOLUTION MODO 801 DRIVER

When your application code sends polygons to OpenGL, the driver places them into the FIFO and returns to your application. Typically, there is a large FIFO buffer on the front end of the graphics card. This fails because OpenGL implementations are almost always pipelined - that is to say, things are not necessarily drawn when you tell OpenGL to draw them - and the fact that an OpenGL call returned doesn't mean it finished rendering. Perhaps the most common error in measuring the performance of an OpenGL program is to say something like: