FlightGear wiki - User contributions [en]

Bindings

2025-05-09T16:14:17Z

MariuszXC: corrected a file name

'''Bindings''' define what happens when a user:
* [[Howto: Make a clickable panel|Clicks an object]] in the [[scenery]] or in an [[aircraft]].
* Presses a key/button on the keyboard or [[joystick]].
* Clicks a [[menu]] item
* Interacts with a dialog (clicking a button, selecting list entries etc)

In other words, '''bindings''' are simply the term for '''actions''' that are associated with certain '''events''' in FlightGear.

There are different types of events supported by various subsystems, but the resulting action that can be triggered will typically involve either a hard-coded command (a so called <code>fgcommand</code>), or a block of scripted code (using [[Nasal]]). Bindings can be parameterized / customized using properties as arguments that are passed to each binding as a props.Node object.
And Nasal code can also be registered to become available as a dedicated <code>fgcommand</code>.

An object, button or key can have multiple bindings assigned to them. The bindings will be executed in the order in which they appear in the XML file. Bindings may contain [[conditions]] to make them conditionally executed. Each binding must specify a command node with its particular type, see below.

{{Note|Aircraft are free to override key bindings to fullfill their needs. The Space Shuttle for instance has no mixture control, so the m-key switches from translational to rotational hand controller.
The key only performs as mixture control if the plane has mixture settings and if the plane didn't re-assign the key - so dependent on what plane you try, it may or may not. Usually the aircraft-specific help spells it out.<ref>{{cite web
|url = https://forum.flightgear.org/viewtopic.php?p=298436#p298436
|title = <nowiki> Re: trouble with m-key </nowiki>
|author = <nowiki> Thorsten </nowiki>
|date = Nov 9th, 2016
|added = Nov 9th, 2016
|script_version = 0.40
}}</ref>
}}

This article gives a small overview of frequently used bindings. Please refer to {{readme file|commands}} for additional information and refer to <code>$FG_SRC/Main/fg_commands.cxx</code> for a complete list of available bindings.

All given codes are examples, found on various places in the [[FlightGear]] package.

== Commands ==
Below are some useful commands, some also with their equivalent Nasal call. A more complete listing can be found in the readme file, {{readme file|commands}}.

To learn more about adding your own custom <code>fgcommands</code> to the source code, see [[Howto:Add new fgcommands to FlightGear]].

=== replay ===
Toggles replay.
<syntaxhighlight lang="xml">
<binding>
<command>replay</command>
</binding>
</syntaxhighlight>
<syntaxhighlight lang="nasal">
fgcommand("replay");
</syntaxhighlight>

=== dialog-close ===
Closes the active dialog.
<syntaxhighlight lang="xml">
<binding>
<command>dialog-close</command>
</binding>
</syntaxhighlight>
<syntaxhighlight lang="nasal">
fgcommand("dialog-close");
</syntaxhighlight>
To close a specific dialog use for example:
<syntaxhighlight lang="nasal">
fgcommand("dialog-close", props.Node.new({"dialog-name": "chat-full"}));
</syntaxhighlight>

=== dialog-show ===
Shows a dialog, which should be present in <tt>''[[$FG_ROOT]]/gui/dialogs''</tt>. In addition, from FlightGear 2.8, dialog files located in <tt>''<aircraft directory>/gui/dialogs''</tt> are also loaded. This should be used for dialogs specific to a certain aircraft.
<syntaxhighlight lang="xml">
<binding>
<command>dialog-show</command>
<dialog-name>location-in-air</dialog-name>
</binding>
</syntaxhighlight>
<syntaxhighlight lang="nasal">
fgcommand("dialog-show", props.Node.new({"dialog-name": "location-in-air"}));
</syntaxhighlight>

; dialog-name : The name of the dialog, as designated in its XML file.

=== nasal ===
[[Nasal]] is frequently used for complicated systems, because it can execute virtually any function and allows running previously-defined Nasal functions.
<syntaxhighlight lang="xml">
<binding>
<command>nasal</command>
<script>b777.afds.input(0,1);</script>
</binding>
</syntaxhighlight>

; script : The Nasal script to execute.
: {{inote|Make sure that the script does not conflict with the {{wikipedia|List of XML and HTML character entity references#Predefined entities in XML|predefined XML entities}}. If it does, you can either put it in a {{wikipedia|CDATA|CDATA section}} or use a non-interpreted version (e.g., <code>&gt;</code> in place of <code>></code>).}}

The {{func link|cmdarg()}} function is often useful in these situations to extract offset values passed to the binding. It returns the specific <tt><binding></tt> node, which contains a <tt><setting></tt> node at runtime if used in a joystick axis that represents the value of that axis.

In joysticks and keyboard keys, the script is run in a specific namespace; please see [[Howto:Understand Namespaces and Methods]] for more information on namespaces.

=== property-adjust ===
Increases or decreases a property's value with a given step. Maximum and minimum values are optional.
<syntaxhighlight lang="xml">
<binding>
<command>property-adjust</command>
<property>/autopilot/settings/heading-bug-deg</property>
<step>1</step>
<min>0</min>
<max>360</max>
<wrap>true</wrap>
</binding>
</syntaxhighlight>

; property : Property that will be changed.
; step : Amount to increase or decrease the property's value. Defaults to 0.
; offset : Offset from the property's current value. If '''step''' is not given, this is multiplied by '''factor'''.
; factor : When '''step''' is not given, '''offset''' is multiplied by this. Defaults to 1.
; min : The minimum allowed value. Defaults to "no minimum."
; max : The maximum allowed value. Defaults to "no maximum."
; wrap : If true, the value will be wrapped when it passes min or max; both min and max must be present for this to work. Defaults to false.:{{Note|When wrap is set to true, the max parameter must be set to the desired maximum value + step or factor in order to work correctly !}}
; mask :This argument accepts three value: <code>integer</code>, <code>decimal</code> and <code>all</code> (default). <code>integer</code> means that <code>step</code> or <code>offset * factor</code> is applied to the part of the property's current value left of the decimal point first. <code>decimal</code> does the same, but applies it to the part to the right of the decimal point. <code>all</code> simply applies it to the whole number. This is especially useful for COM / NAV radio frequency knobs - use <code>integer</code> for the outer (big) knob and <code>decimal</code> for the inner (small) knob.

=== property-assign ===
One of the most important commands. It sets a property to a predefined value or to the value of another property.<ref>{{flightgear source
| path = src/Main/fg_commands.cxx
| line = 446
}}</ref>
<syntaxhighlight lang="xml">
<binding>
<command>property-assign</command>
<property>/autopilot/settings/target-speed-kt</property>
<value>0</value>
</binding>
</syntaxhighlight>
or<syntaxhighlight lang="xml">
<binding>
<command>property-assign</command>
<property>autopilot/input/hdg</property>
<property>instrumentation/heading-indicator/hdg-autopilot</property>
</binding>
</syntaxhighlight>

=== property-cycle ===
Cycles between a list of values and assigns one to a property. The value-list can vary in length. If the current value is <code>value1</code>, it will change to <code>value2</code>; if it is <code>value2</code>, it will change to <code>value3</code>, and so on. If the current value is not in the list, it will jump to the first one.
<syntaxhighlight lang="xml">
<binding>
<command>property-cycle</command>
<property>/autopilot/autobrake/setting</property>
<value type="string">ARM</value>
<value type="string">DISARM</value>
<value type="string">OFF</value>
</binding>
</syntaxhighlight>
As of May 2013, the command supports additional behaviours to simplify use with the new [[Knob_/_slider_animation|knob and slider animations]]. The wrapping behaviour can be disabled by setting <code><wrap>0</wrap></code>, and the command uses the <code>offset</code> argument to select a direction of movement. This means a <code>property-cycle</code> bound to a multi-position knob will function as expected for movement in both directions.

=== property-interpolate ===
Interpolates to a value with a given rate of change (per second).
<syntaxhighlight lang="xml">
<binding>
<command>property-interpolate</command>
<property>/controls/flight/aileron-trim</property>
<value type="double">0</value>
<rate>0.5</rate>
</binding>
</syntaxhighlight>

Instead of using <code><rate></code>, one could use <code><nowiki><time></nowiki></code><time>, to specify the time (in seconds) it takes to go to the new value, independent of the current value.
<syntaxhighlight lang="xml">
<binding>
<command>property-interpolate</command>
<property>/controls/flight/aileron-trim</property>
<value type="double">0</value>
<time>2</time>
</binding>
</syntaxhighlight>

You can also interpolate to a value given by a property.
<syntaxhighlight lang="xml">
<binding>
<command>property-interpolate</command>
<property>/controls/flight/aileron-trim</property>
<property>/controls/flight/default-aileron-trim</property>
<rate>0.5</rate>
</binding>
</syntaxhighlight>

=== property-multiply ===
Multiply the value of a property by a given factor.
<syntaxhighlight>
<binding>
<command>property-multiply</command>
<property>/controls/flight/aileron</property>
<factor>0.5</factor>
<min>-1</min>
<max>1</max>
<mask>all</mask>
<wrap>true</wrap>
</binding>
</syntaxhighlight>
*'''factor:''' the amount to multiply by.
*'''min:''' minimum value.
*'''max:''' maximum value.
*'''mask:'''
** '''integer:''' mutiply only left of the decimal point.
** '''decimal:''' multiply only the right of the decimal point.
** '''all:''' multiply the entire value.
*'''wrap:''' true if the value should be wrapped if it passes min/max. It is required to set both min and max in that case.

=== property-randomize ===
Assigns a random value (between min and max) to a property.
<syntaxhighlight lang="xml">
<binding>
<command>property-randomize</command>
<property>/orientation/pitch-deg</property>
<min>0</min>
<max>360</max>
</binding>
</syntaxhighlight>

=== property-scale ===
Set the value of a property based on an axis, often used in [[joystick]] configuration files.
<syntaxhighlight lang="xml">
<binding>
<command>property-scale</command>
<property>/controls/flight/aileron</property>
<offset>0.001</offset>
<factor>-1</factor>
<power>3</power>
</binding>
</syntaxhighlight>

* '''setting:''' the current input setting (usually a joystick axis from -1 or 0 to 1)
* '''offset:''' the offset to shift by, before applying the factor.
* '''factor:''' the factor to multiply by (use negative to reverse).
* '''squared:''' if true will square the resulting value (same as power=2).
* '''power:''' the resulting value will be taken to the power of this integer value (overrides squared).

Remember: <code>(property ^ power + offset) * factor = result</code>

=== property-swap ===
Swaps the values of two properties, useful for radio panels.
<syntaxhighlight lang="xml">
<binding>
<command>property-swap</command>
<property>/instrumentation/comm/frequencies/selected-mhz</property>
<property>/instrumentation/comm/frequencies/standby-mhz</property>
</binding>
</syntaxhighlight>

=== property-toggle ===
Toggles the value of a property on each click, between <code>true</code> <code>(1</code>) and <code>false</code> (<code>0</code>):
<syntaxhighlight lang="xml">
<binding>
<command>property-toggle</command>
<property>/controls/gear/gear-down</property>
</binding>
</syntaxhighlight>
Or - if defined - it toggles between two custom values:
<syntaxhighlight lang="xml">
<binding>
<command>property-toggle</command>
<property>/controls/gear/gear-down</property>
<value>2</value>
<value>3</value>
</binding>
</syntaxhighlight>

===request-metar ===
{{cquote|
<syntaxhighlight lang="nasal">
fgcommand("request-metar", props.Node.new({"path": "/foo/mymetar", "station": "LOWI"}));
</syntaxhighlight>

If you pass an existing path, the station ID will be updated, and if you pass the same station ID as before, no additional request is made. As usual for metar-properties, there's a time-to-live and valid flags you can check, and the metar refreshes automatically every 900 seconds. You can also write to the station ID directly to change station, update the time-to-live, and wait for the valid signal.

There's also an unregister command ('clear-metar') to cancel the binding into the property tree.<ref>{{cite web |url=http://www.mail-archive.com/flightgear-devel@lists.sourceforge.net/msg38372.html|title=<nowiki>[Flightgear-devel] Requesting arbitrary metar</nowiki>|author=James Turner|date=Sun, 23 Sep 2012 08:56:48 -0700}}</ref>|James Turner}}

<references/>

== Related content ==
=== Wiki ===
* [[Conditions]]
* [[Howto:Make a clickable panel]]
* [[Howto:Reassign keyboard bindings]]

=== Forum topics ===
* {{forum link|t=37443|title=Order of multiple bindings}}
* {{forum link|t=37447|title=Amending to key bindings}} - Partially about indices (<code><nowiki><binding n="<index>"></nowiki></code>) for bindings.

=== Readme file ===
* {{readme file|commands}}

=== Source ===
Note that many commands are defined elsewhere. The readme file has a more complete listing.

* {{flightgear source|path=src/Main/fg_commands.hxx}}
* {{flightgear source|path=src/Main/fg_commands.cxx}}

* {{simgear source|path=simgear/structure/commands.hxx}}
* {{simgear source|path=simgear/structure/commands.cxx}}

[[Category:Development]]
[[Category:XML]]
[[Category:FlightGear keyboard]]
[[Category:Joysticks and Yokes]]

Developing and debugging Nasal code

2025-04-21T19:37:23Z

MariuszXC: /* Debugging */ - add link to Wiki entry

{{Template:Nasal Navigation}}

==Developing and debugging in Nasal==
===Developing Nasal code===
Because code in the Nasal directory is parsed only at FlightGear startup, testing and debugging Nasal code can be slow and difficult.

FlightGear provides a couple of ways to work around this issue:

====Nasal Console====

The Nasal Console is available in FlightGear's menu (Debug/Nasal Console). Selecting this menu opens a Nasal Console dialog.

This dialog has several tabs, of which each can hold separate Nasal code snippets, all of which are saved on exit
and reloaded next time. This is useful for little tests, or for executing code for which writing a key binding is just too much
work, such as "props.dump(props.globals)".

If you want to add more tabs (radio buttons in the Nasal Console dialog) to hold more code samples, just add more <code> nodes to autosave.xml.

[[Nasal Console]]

====Loading/reloading Nasal code without re-starting FlightGear====
A common problem in testing and debugging Nasal programs is that each testing step requires stopping and re-starting FlightGear, a slow process.

Below is described a technique for loading and executing a Nasal file while FlightGear is running. FlightGear will parse the file, display any errors in the FlightGear console window, and then execute the code as usual.

Using this technique, you can start FlightGear, load the Nasal code you want to test observe any errors or test functionality as you wish, make changes to the Nasal file, reload it to observe parse errors or change in functionality, and so on to repeatedly and quickly run through the change/load/parse/test cycle without needing to re-start FlightGear each time.

The key to this technique is the function io.load_nasal(), which loads a nasal file into a nasal namespace.

Step-by-step instructions showing how to use this technique to load, parse, and test a Nasal file while FlightGear is running:

=====Create the Nasal file to test=====
Create a text file named [[$FG_ROOT]]/foo/test.nas with this text:

print("hi!");
var msg="My message.";
var hello = func { print("I'm the test.hello() function") }

Notes: You can create the file in any directory you wish, as long as Nasal can read the directory--but the file IOrules in the Nasal directory restricts which directories Nasal may read and write from.

You can give the file any name and extension you wish, though it is generally most convenient to use the .nas extension with Nasal files.

=====Load the file and test=====
Start FlightGear. You can import the file above into FlightGear by typing the following into the Nasal Console dialog and executing the code:

io.load_nasal(getprop("/sim/fg-root") ~ "/foo/test.nas", "example");

getprop("/sim/fg-root") gets the root directory of the FlightGear installation, ~ "/foo/test.nas" appends the directory and filename you created. The final variable "example" tells the namespace to load for the Nasal file.

You'll see the message "hi!" on the terminal, and have function "example.hello()" immediately available. You can, for instance, type "example.hello();" into one of the Nasal console windows and press "Execute" to see the results; similarly you could execute "print (example.msg);".

If you find errors or want to make changes, simply make them in your text editor, save the file, and execute the io.load_nasal() command again in the Nasal Console to re-load the file with changes.

It's worth noting that Nasal code embedded in XML GUI dialog files can be reloaded by using the "debug" menu ("reload GUI").

You may also want to check out the remarks on [[Nasal scripting language#Memory management|Memory management]].

==== Managing timers and listeners ====

Note: If your Nasal program sets listeners, timer loops, and so on, they will remain set even when the code is reloaded, and reloading the code will set additional listeners and timer loops.

This can lead to extremely slow framerates and unexpected behavior. For timers you can avoid this problem by using the loopid method (described above); for listeners you can create a function to destroy all listeners your Nasal program creates, and call that function before reloading the program. (And cleaning up timer loops and listeners is a best practice for creating Nasal programs in FlightGear regardless.)

The same problem may occur while resetting or re-initializing parts of FlightGear if your code isn't prepared for this. And obviously this applies in particular also to any worker threads you may have started, too!

For complex Nasal scripts with many timers and listeners, it is therefore generally a very good idea to implement special callbacks so that your scripts can respond to the most important simulator "signals", this can be achieved by registering script-specific listeners to signals like "reinit" or "freeze" (pause): the corresponding callbacks can then suspend or re-initialize the Nasal code by suspending listeners and timers.
Following this practice helps ensure that your code will behave properly even during simulator resets.

In other words, it makes sense to provide a separate high-level controller routine to look for important simulator events and then pause or re-initialize your main Nasal code as required.

If you are using [[Nasal scripting language#System-wide Nasal code|System-wide Nasal modules]], you should register listeners to properly re-initialize and clean up your Nasal code.

In its simplest form, this could look like this:

<syntaxhighlight lang="nasal">
var cleanup = func {}
setlistener("/sim/signals/reinit", cleanup);
</syntaxhighlight>

This will invoke your "cleanup" function, whenever the "reinit" signal is set by the FlighGear core.

Obviously, you now need to populate your cleanup function with some code, too.

One of the easiest ways to do this, is removing all listeners/timers manually here, i.e. by adding calls to removelistener():

<syntaxhighlight lang="nasal">
var cleanup = func {
removelistener(id1);
removelistener(id2);
removelistener(id3);
}
</syntaxhighlight>

This would ensure that the corresponding listeners would be removed once the signal is triggered.

Now, keeping track of all listeners manually is tedious.

On the other hand, you could just as well use a vector of listener IDs here, and then use a Nasal foreach loop:

<syntaxhighlight lang="nasal">
var cleanup = func(id_list) {
foreach(var id; id_list)
removelistener(id);
}
</syntaxhighlight>

Obviously, this would require that you maintain a list of active listeners, too - so that you can actually pass a list of IDs to the cleanup function.

This is one of those things that can be easily done in Nasal, too - just by introducing a little helper wrapper:

<syntaxhighlight lang="nasal">
var id_list=[];
var store_listener = func(id) append(id_list,id);
</syntaxhighlight>

The only thing required here, would be replacing/wrapping the conventional "setlistener" call with calls to your helper:

<syntaxhighlight lang="nasal">
store_listener( setlistener("/sim/foo") );
store_listener( setlistener("/foo/bar") );
</syntaxhighlight>

If you were to do this consistently across all your Nasal code, you'd end up with a high level way to manage all your registered listeners centrally.

You could further generalize everything like this:

<syntaxhighlight lang="nasal">
var id_list=[];
var store_listener = func(property) append(id_list,setlistener(property) );
store_listener("/sim/foo/bar");
</syntaxhighlight>

This will ensure that any "store_listener" call stores the listener's ID in the id_list vector, which makes it possible to easily remove all listeners, too:

<syntaxhighlight lang="nasal">
var cleanup_listeners = func {
foreach(var l; id_list)
remove_listener(l);
}
</syntaxhighlight>

Similarly, you could just as well "overload" functions like settimer() setlistener() in your script, this can be easily achieved by saving a handle to the original functions and then overriding them in your script:

<syntaxhighlight lang="nasal">
var original_settimer = settimer;
var original_setlistener = setlistener;
</syntaxhighlight>

Now, you have handles stored to the original functions, to make sure that you are referring to the correct version, you can also refer to the "globals" namespace.

Obviously, it makes sense to only store and clean up those listeners that are not themselves required to handle initialization/resets, otherwise you'd remove the listeners for your init routines, too.

Next, you can easily override settimer/setlistener in your script:

<syntaxhighlight lang="nasal">
var original_settimer = settimer;
var original_setlistener = setlistener;

var settimer = func(function, time, realtime=0) {
print("Using your own settimer function now");
}

var setlistener = func(property, function, startup=0, runtime=1) {
print("Using your own setlistener function now!");
}
</syntaxhighlight>

In order to call the old implementation, just use the two handles that you have stored:

* original_settimer
* original_setlistener

<syntaxhighlight lang="nasal">
var original_settimer = settimer;
var original_setlistener = setlistener;

var settimer = func(function, time, realtime=0) {
print("Using your own settimer function now");
original_settimer(function, time, realtime);
}

var setlistener = func(property, function, startup=0, runtime=1) {
print("Using your own setlistener function now!");
original_setlistener(property, function, startup, runtime);
}
</syntaxhighlight>

So this is a very simple and elegant way to wrap and override global behavior. So that you can easily implement script-specific semantics and behavior, i.e. to automatically store handles to registered listeners:

<syntaxhighlight lang="nasal">
var original_settimer = settimer;
var original_setlistener = setlistener;

var cleanup_listeners = [];

var settimer = func(function, time, realtime=0) {
print("Using your own settimer function now");
original_settimer(function, time, realtime);
}

var setlistener = func(property, function, startup=0, runtime=1) {
print("Using your own setlistener function now!");
var handle = original_setlistener(property, function, startup, runtime);
append(cleanup_listeners, handle);
}
</syntaxhighlight>

Thus, you can now have a simple "cleanup" function which processes all listeners stored in "cleanup_listeners" using a foreach loop and removes them:

<syntaxhighlight lang="nasal">
var original_settimer = settimer;
var original_setlistener = setlistener;

var cleanup_listeners = [];

var remove_listeners = func {
foreach(var l; cleanup_listeners) {
removelistener(l);
}
}

var settimer = func(function, time, realtime=0) {
print("Using your own settimer function now");
original_settimer(function, time, realtime);
}

var setlistener = func(property, function, startup=0, runtime=1) {
print("Using your own setlistener function now!");
var handle = original_setlistener(property, function, startup, runtime);
append(cleanup_listeners, handle);
}
</syntaxhighlight>

The only thing that's needed now to handle simulator resets, is registering an "anonymous" listener which triggers your "remove_listeners" callback upon simulator reset:

<syntaxhighlight lang="nasal">
_setlistener( "/sim/signals/reinit", remove_listeners );
</syntaxhighlight>

Note how we're using the low level _setlistener() call directly here, to avoid adding the listener id to the "cleanup" vector, which would mean that we're also removing this listener - i.e. the cleanup would then only work once.

Now, you'll probably have noticed that it would make sense to consider wrapping all these helpers and variables inside an enclosing helper class, this can be accomplished in Nasal using a hash.

This would enable you to to implement everything neatly organized in an object and use RAII-like patterns to manage Nasal resources like timers, listeners and even threads.

===Debugging===
The file [[Nasal library/debug|debug.nas]], included in the Nasal directory of the FlightGear distribution, has several functions useful for debugging Nasal code. These functions are available to any Nasal program or code executed by FlightGear.

Aside from those listed below, several other useful debugging functions are found in debug.nas; see the debug.nas file for the list of functions and explanation. You may also refer to this Wiki entry: [[Nasal library/debug]].

Note that the debug module makes extensive use of ANSI terminal color codes. These create colored output on Linux/Unix systems but on other systems they may add numerous visible control codes. To turn off the color codes, go to the internal property tree and set

/sim/startup/terminal-ansi-colors=0

Or within a Nasal program:

setprop ("/sim/startup/terminal-ansi-colors",0);

====debug.dump====
debug.dump([<variable>]) ... dumps full contents of variable or of local variables if none given

The function debug.dump() dumps the contents of the given variable to the console. On Unix/Linux this is done with some syntax coloring. For example, these lines

var as = props.globals.getNode("/velocities/airspeed-kt", 1);
debug.dump(as);

would output

</velocities/airspeed-kt=1.021376474393101 (DOUBLE; T)>

The "T" means that it's a "tied" property. The same letters are used here as in the property-browser. The angle brackets seem superfluous, but are useful because debug.dump() also outputs compound data types, such as vectors and hashes. For example:

var as = props.globals.getNode("/velocities/airspeed-kt", 1);
var ac = props.globals.getNode("/sim/aircraft", 1);
var nodes = [as, ac];
var hash = { airspeed_node: as, aircraft_name: ac, all_nodes: nodes };
debug.dump(hash);

yields:

{ all_nodes : [ </velocities/airspeed-kt=1.021376474393101 (DOUBLE; T)>,
</sim/aircraft="bo105" (STRING)> ], airspeed_node : </velocities/airspe
ed-kt=1.021376474393101 (DOUBLE; T)>, aircraft_name : </sim/aircraft="bo
105" (STRING)> }

====debug.backtrace====
debug.backtrace([<comment:string>]} ... writes backtrace with local variables
debug.bt ... abbreviation for debug.backtrace

The function debug.backtrace() outputs all local variables of the current function and all parent functions.

====debug.breakpoint====
If you need a backtrace controlable via the property browser at runtime, this is for you.
see [[Nasal library/debug]]

====debug.benchmark====
debug.benchmark(<label:string>, <func> [, <repeat:int>])
... runs function <repeat> times (default: 1) and prints execution time in seconds,prefixed with <label>.

This is extremely useful for benchmarking pieces of code to determin
====debug.exit====
debug.exit() ... exits fgfs

[[Category:Nasal]]

Canvas news

2024-11-11T21:12:43Z

MariuszXC: /* Skia talks */ fix small typo

{{Canvas Navigation}}

This page is primarily intended to keep track of Canvas related core/fgdata changes and discussions, i.e. mainly of interest to people who are not able to follow the forum/devel list regularly, but who may still want to stay up to date regarding future Canvas developments (i.e. not including fgaddon).

Everybody is invited to help contribute to maintain this page and provide up-to-date information. Also, quoting/referincing devel/forum list talks is actively encouraged, too - to help provide the corresponding pointers back to the original discussion threads: [[Instant-Cquotes]].

{{Canvas Roadmap}}

== 2023 ==
=== Pango Text ===
{{Stub}}
[[File:Pango-text-03-2023.png|thumb|we'd use the Pango library with it's dependencies, write our ownrenderer and set_renderer(custom_renderer) on the rendering context ?If you think this is a good idea I'll look into it, if not - I have a pureOSG solution working, for fill color at least<ref>https://sourceforge.net/p/flightgear/mailman/message/37791568/</ref>]]
On the long hand we need to implement simple, GTK like markup support for
canvas.Text, mainly for easy selection handling (I have that working for
single-line text, but it's got visual artifacts and it would be incredibly
complicated to make it work for multi-line text), but there are other use
cases too (like syntax highlighting in the Nasal console, etc.).<ref>https://sourceforge.net/p/flightgear/mailman/message/37781788/</ref>

Successfully subclassed Pango::Renderer, and
I'm also successfully showing an osg::Texture2D as element on the canvas,
but when I try to copy an osgText::Glyph onto that texture, instead of a
glyph I get a noise texture instead … the other issue I'm having is some
ponter problem (a smart pointer of one CanvasPangoText instance only
getting deleted upon the creation of the next instance, which leads to it
wanting to delete something that was already deleted !?).
On both problems I'm somewhat stuck, so it would be great if @James Turner
<ja...@fl...> or @Hooray could take a look - the latest code is
available at git.code.sf.net/u/thefgfseagle/simgear.git / branch
canvas_pangotext, in
simgear/canvas/elements/{CanvasPangoText,PangoRendererCanvas}.cxx<ref>https://sourceforge.net/p/flightgear/mailman/message/37795860/</ref>

And the new element can be tested with the following Nasal code, after
checking out the canvas_pangotext branch from
git.code.sf.net/u/thefgfseagle/fgdata <ref>https://sourceforge.net/p/flightgear/mailman/message/37795864/</ref>:
<pre>
w = canvas.Window.new([200, 200], "dialog");
c = w.createCanvas();
g = c.createGroup();
t = g.createChild("pangotext");
t.setMarkup("<b>bold</b>");
w.show();
</pre>

=== PUI Emulation ===
{{Main article|PUI}}

[[File:Gc-monitoring-via-new-canvas-proptree-widget.png|thumb|Screen shot showing a [[Canvas GUI]] dialog rendering the new [[Property browser]] dialog based on porting the legacy [[PUI]] widget, showing GC stats]]
01/2023: James slowly working on creating the pop-up menu and combo-box widgets [...] We need to figure out the split of DefaultStyle.nas, but James is very keen to ensure we add a second style alongside the default, before we change much here.

Regarding styling, James is worried about us ending up putting code into the wrong side of the widget / Style split, if we don’t have a second alternative style implementation to ‘keep us honest’<ref>https://sourceforge.net/p/flightgear/mailman/message/37756178/</ref>

We really have two kinds of ’styles’

* tweaking margins, font sizes, colours etc should indeed be done in XML as you wrote : this is also analogous to styles in the PUI sense

* making radically different ways of presenting the same logical widgets: eg text label of checkbox in a different position relative to the button (of Surface vs Material vs iOS style, if you know web/mobile UIs)

For the second kind we would use a different Nasal style implementation and that’s the abstraction I think it is very important to maintain. It of course going to be a lot of work to make additional styles this way but it’s a very valuable feature to keep the possiblity, since it enables alternate UIs for user accessibility or different presentation modes such as VR.

What I don’t want to do is add lots of widgets assuming we only care about DefaultStyle.nas, and then have an impossible mountain to climb when someone needs an alternate Nasal style. We don’t have to make a complete alternate style now, but I don’t want to take shortcuts the make it impossible in the future. So I want to really think carefully about what is widget code and what is style code. <ref>https://sourceforge.net/p/flightgear/mailman/message/37756261/</ref>

One of the major things slowing down James' work on the popup-menu and combo box is time to restart the simulator for each change, he is looking for some solution to re-load the widget Nasal code independently. <ref><https://sourceforge.net/p/flightgear/mailman/message/37756183/</ref>

James has done about 75% (hah!) of the C++ work to enable live reloading of modules this way, but unfortunately there are some code paths that would become crashy if you use the feature for the Canvas: because it would reference the ‘old’ (pre-reload) Nasal code, and not the new one, and therefore you’d get a weird mix of old and new, and then just crash the sim. To fix it properly I need to track down those places that store a reference to Canvas and give them a re-init method, so we don’t keep the stale references.

The general non-fun-ness of that kind of debugging is why I’ve been making such slow progress on my PUI replacement widgets recently <ref>https://sourceforge.net/p/flightgear/mailman/message/37756263/</ref>

== 2022 ==
=== ListView Widget ===
[[File:Logbook-v.1.1.0.png|thumb]]
For the [[Logbook Add-on]], PlayeRom implemented a ListView canvas widget that can be reused by others, so he sent a merge request with this widget.<ref>https://sourceforge.net/p/flightgear/mailman/message/37754894/</ref>

see also {{Merge-request|project=fgdata|id=304|text=Merge request:Canvas ListView implementation}}
=== Tab Widget ===
[[File:Canvas TabWidget example.png|thumb]]
[[File:TabWidget.png|thumb|TheEagle's tab widget]]
FGFSEagle needed a tab widget for his C310, so he did a quick implementation inspired
by FGAddon/trunk/Aircraft/f16/Nasal/canvas/gui/widgets/Tabs.nas.

The plan is to add scrolling / reordering / closing support for the tabs later. <ref>https://sourceforge.net/p/flightgear/mailman/message/37751388/ </ref>

Learn more at [[Canvas snippets#Using_TabWidgets]]

For the merge request, see see {{Merge-request|project=fgdata|id=303|text=Canvas tab widget implementation}}

For the underlying idea, refer to: [[PUI#Replacement status]]

=== Releasing Canvas textures ===
{{Stub}}

we'd need some kind
of way to delete the texture without deleting the window, redrawing the
texture when the window is reopened ? Starts to sound complicated … but on
the other hand, all windows on the Extra 500 use a custom Window class
which does something similar … <ref>https://sourceforge.net/p/flightgear/mailman/message/37719030/</ref>
I've updated the code to directly hide the window when the close button is
pressed, and also fixed a bug which consisted of the windows automatically
showing (which is not desired when the window is constructed at startup and
should only be shown later). New patch attached.
As for memory usage, I did a test - 100 1000x1000 px canvas windows, all
with destroy_on_close = 0. constructing them didn't give a significant
increase in memory usage - only upon showing them all at once, the RAM
usage went up by 2 GB. that's quite a lot you might say, but 1) most
dialogs are not as big as that and 2) which user opens 100 dialogs in one
session ? In most cases it won't be more than 10 = 200 MB RAM (if all
dialogs were using this new behaviour) - and the default behaviour is to
destroy the window on closing anyways (destroy_on_close = 1 by default, you
got to explicitly set it to 0 to get the new behaviour, also to maintain
backwards compatibility), so I think this won't be an issue.<ref>https://sourceforge.net/p/flightgear/mailman/message/37719123/</ref>

What we’d ideally want is a C++ change so that hidden canvases release their texture memory : it’s created the first time the canvas is rendered, which is why the memory is fine until you actually show them.

200MB memory is not great, but the bigger problem is the GPU-side memory : 200MB of VRAM is much more ‘valuable’ for textures than for keeping the backing store of hidden dialogs. So I would definitely say use this feature sparingly, until someone adds some C++ logic to destroy the backing texture for hidden canvas windows.<ref>https://sourceforge.net/p/flightgear/mailman/message/37720688/</ref>

For this window behaviour one, I’ve applied it since it’s an opt-in change, but I suspect we may end reviewing this API a little, so I’d suggest not building lots of dialogs across different aircraft, which depend on this behaviour, until we get a bit more experience with it.

So use it, gain some understanding, but maybe we discover in 6 months that it’s a bad idea and have to revert it. (That’s the worst case, but it is kind of a radical change in the lifetime / memory usage of the Canvas, so I just want to mention the worst possibility) I’m 90% sure we can keep this API, so long as we improve the C++ behaviour to release the texture / FBO memory of hidden canvases, which is a reasonable thing to do anyway, it just needs someone to have the time to implement that, and right now, I certainly don’t.<ref>https://sourceforge.net/p/flightgear/mailman/message/37720701/</ref>

=== Replacing PUI ===
{{See also|PUI#Replacement_status}}

Update 09/2022: The PUI replacement was going to be Qt but it started to get very complicated with changes in Qt 5.15 + Qt 6, so James is going with a more light-weight, Canvas-based, approach now.

Qt added support for Vulkan / Metal / D3D starting in 5.15, but FlightGear / OpenSceneGraph can’t support those, so integrating the two renderers went from being ‘complicated but ok’ to ‘very very complicated’.

So now James is going with something much more lightweight using some C++ compatibility code, some Nasal for styling and the existing widget rendering from Thomas Geymayer (TheTom) with some extensions and additions: some pieces are in FlightGear & FGData already.

James has basic dialogs working okay but not the more complex ones and everything looks kind of ugly, he needs to improve the visual look before he shares screenshots to avoid everyone freaking out :) The disadvantage of this approach is James is far from expert at creating visual appearances this way, so it’s kind on unrewarding and slow for him. If someone likes messing with CSS-type styling, border-images and hover-states, ping him since we could probably move things also faster <ref>https://sourceforge.net/p/flightgear/mailman/message/37701750/</ref>

The PUI limitations should be gone ‘soon’: actually James is now focused on getting dialogs working; on macOS we use a native menubar (not PUI) inside FG which can handle sub-menus just fine.

If someone out there wants to work on the UI for menus / menubar part, just ping him directly, he can suggest some steps to start working that way. (Basically creating the view code in Nasal for menu items, menus and the menubar, and handling the different visual states of the above, such as an item being disabled, showing the keyboard shortcut, eliding too-long item names, hover feedback, timers to open menus / sub-menus on mouse-over: it’s all pretty standard stuff)

This does *also* need C++ parts, because the internal menubar structure /also/ needs some additions to support sub-menus, and the add-ons themselves would likely need some tweaks in the XML to integrate with that. So in total there are quite a few changes in this ’simple’ request, but this is often the way with software development :)<ref>https://sourceforge.net/p/flightgear/mailman/message/37701747/</ref>

{{Main article|pui2canvas}}

In February 2022, James reported having something in progress locally, and that should even be something we can try in March/April 2022. Hopefully that’s quick enough, knowing it has been a long time coming.<ref>https://sourceforge.net/p/flightgear/mailman/message/37606439/</ref>

It’s split between Simgear (see classes with widget / layout in the name) and in FGData. (Eg widgets/Button.nas) To be able to use the existing dialog XML files un-modified (which is a design goal), James is extending the widget types with many additional ones (eg PUI has slider, dial, combo-box, checkbox, all of which need to be created - this is about 30% done and is the bit he's very slow at). Thomas’s widgets have a very good separation of API + state from appearance, so all styling is in its own file, and James is being very strict about maintaining this separation, so we also retain the re-styling feature of the PUI UI, which many people also rely on. This does make the process of adding new widgets more complex, however.

The other thing is to preserve all the layouting : James has added a grid layout to Simgear, since that is supported by the existing PUI code (even though the layouts are not actually part of PUI itself). The problem is getting the sizing / hinting of all the widgets to match the PUI values, so that dialogs look approximately the same under the new UI as they did with PUI; again this a design goal so that all existing dialogs in aircraft and add-ons, which we can’t update, continue to work and be usable. Debugging that is also proving quite tricky, since there’s all kinds of hard-coded assumptions built into PUI widgets about pixels, font-sizes etc which are not true in the new system.<ref>https://sourceforge.net/p/flightgear/mailman/message/37701792/</ref>

=== XMLDialog.nas ===

{{Main article|pui2canvas}}

There's now an XML to Nasal bridge, to keep PUI dialogs working (Disabled by a CMake option)
This is implemented on top of the [[Canvas]] system.

James reported having something in progress locally, and that should even be something we can try in 2022. Hopefully that’s quick enough, knowing it has been a long time coming.<ref>https://sourceforge.net/p/flightgear/mailman/message/37606439/</ref>

The new code builds equivalent C++ objects to what the [[PUI]] dialogs build, with properties exposed to [[Nasal]].

Peer objects are created by Nasal [[callbacks]], which can implement the various dialog functions needed to keep compatibility, especially the ‘update’ and ‘apply’ hooks.<ref>https://sourceforge.net/p/flightgear/flightgear/ci/cbd5ef9e7b8f433dbc1ba97bae7d7cfc894e7cef/</ref>

Use the following [[Building using CMake|cmake option]] to enable this code: <code>-DENABLE_PUICOMPAT=ON</code>

The new Compatibility files can now be found in $FG_SRC/GUI:

* {{flightgear file|src/GUI/FGPUICompatDialog.cxx }}
* {{flightgear file|src/GUI/FGPUICompatDialog.hxx }}
* {{flightgear file|src/GUI/PUICompatObject.cxx }}

The corresponding Nasal/Canvas module to dynamically "translate" legacy PUI/XML dialogs into Canvas dialogs (at runtime), is to be found in {{fgdata file|Nasal/gui/XMLDialog.nas}} <ref>https://sourceforge.net/p/flightgear/fgdata/ci/fe7c87b21a69f88ddb87d89453c48d12b69660e2/</ref>

=== Core Profile support / replacing ShivaVG ===
[[File:ShivaVG.jpg|thumb|Here is a comparison between ShivaVG and ShaderVG.Look at the Canvas Dialog top left and particularly the vertical airspeed bars <ref>https://sourceforge.net/p/flightgear/mailman/message/37610774/</ref>]]
[[File:ShaderVG.jpg|thumb|Here is a comparison.Look at the Canvas Dialog top left and particularly the vertical airspeed bars<ref>https://sourceforge.net/p/flightgear/mailman/message/37610774/</ref>]]

{{Main article|Shiva Alternatives}}
We need to remove [[PUI]] and change the [[Canvas]] not to use ShivaVG ([[Canvas Path]] back end), to be ES2 compatible or Core-profile compatible.<ref>https://sourceforge.net/p/flightgear/mailman/message/36194973/</ref>

To support [[Canvas]] on [[OpenGL]] [[FlightGear and OpenGL ES|Core profile]], the plan is to migrate from [[Shiva]] to ‘something else’ which implements the required drawing operations. Unfortunately two of the probable solutions (Skia from Chrome and Cairo from Gtk) are both enormous and a pain to deploy on macOS and Windows.

{{See also|Unifying the 2D rendering backend via canvas}}
As part of the Core profile migration, we need to replace ShivaVG (which is the functional guts of Path.cxx) with a shader based implementation, ideally NanoVG, although Scott has indicated this might not be as easy as originally hoped. <ref>https://sourceforge.net/p/flightgear/mailman/message/37605458/</ref>

Early experiments (patch [https://sourceforge.net/p/flightgear/mailman/message/37610741/]) in 02/2022 with ShaderVG were promising and suggest, that it ‘kind of sort of’ works, that’s already less work than integrating NanoVG.<ref>https://sourceforge.net/p/flightgear/mailman/message/37610750/</ref>

For the time being, it's not a one on one drop in replacement but it works quite nicely:
* For one the x,y positions are off comapared to ShivaVG making things slightly bigger (maybe too big for the screen).
* and one issue with the "title bar" being opaque.<ref>https://sourceforge.net/p/flightgear/mailman/message/37610740/</ref>

== 2021 ==
=== Moving Canvas Rendering to a separate OpenGL Context ===
{{Main article|Howto:New Canvas Execution Model}}
[[File:Pbuffer-based-canvas-startup.png|thumb|fgfs initialization with pbuffer based addCamera() modification in renderer.cxx to create canvas cameras in a dedicated GL context]]

[[File:Pbuffer-based-canvas-cams.png|thumb|pbuffer based canvas cams used for offscreen rendering, but also to move canvas rendering out of the main loop (in conjunction with aggressive OSG threading via )
This shows disabled context sharing and use a separate osg::Image to copy the texture from one GL context to another (the CPU being the bottleneck, unless we can use a shader or PBO to do this)]]

[[File:Fgfs-20210904184748.png|thumb|This screen shot shows the FG1000 running in a patched fgfs version where Canvas Cameras are attached to an OpenGL context running in another thread. Synchronization with the main thread is not accomplished using a shared context, but instead using an osg::Image (which considerably slows down things, as can be seen in the stats above)]]

Early experiments moving Canvas rendering out of the main loop by using aggressive OSG threading in conjunction with a separate GL context for Canvas cams, and subsequently, with also moving Nasal (and Property Tree I/O) out of the main loop by using a dedicated thread per Canvas [Texture], probably with its own FGNasalSys instance and related subsystem machinery (mainly, events/timers).

=== Dedicated prerender cams ===
{{See also|Post_FlightGear_2020.2_LTS_changes#Canvas}}
2021-08-27: Fernando has begun working on moving Canvas cameras out of the scene graph into dedicated PRERENDER cams in the viewer (This was a long-standing issue where Canvas cameras were rendered multiple times, once per slave camera. In the case of the Classic pipeline they were being rendered twice.), see:
* {{flightgear commit|83b0a3}}
* {{simgear commit|a97e14}}

== 2020 ==
=== Canvas EFIS Framework ===

The '''canvas EFIS framework''' (created by jsb) is by-product of the EFIS development
done for the CRJ700 family, which uses Rockwell Collins Proline.
It is published as a separate framework in the hope that it is useful for other aircraft as well,
however some features may be rather specific.
The biggest motivation and primary design goal was to support "near optimal"
performance but that does not come automatically of course.

{{Main article|Canvas EFIS Framework}}

== 2019 ==
placeholder for next year

== 2018 ==
=== Compositor ===
{{Main article|Compositor}}

[[File:Compositor-08-2018.png|right|thumb|A screenshot showing post-processed gaussian blur and a blue filter:[https://i.imgur.com/Zzxre8a.png]]]
{{Usr|Icecode}} has been working on and off on multi-pass rendering support for
FlightGear since late 2017. It went through several iterations and
design changes, but he think it's finally on the right track. It's
heavily based on the Ogre3D Compositor and inspired by many
data-driven rendering pipelines. Its features include:

* Completely independent of other parts of the simulator, i.e. it's part of SimGear and can be used in a standalone fashion if needed, ala Canvas.
* Although independent, its aim is to be fully compatible with the current rendering framework in FG. This includes the Effects system, CameraGroup, Rembrandt and ALS (and obviously the Canvas).
* Its functionality overlaps Rembrandt: what can be done with Rembrandt can be done with the Compositor, but not vice versa.
* Fully configurable via a XML interface without compromising performance (ala Effects, using PropertyList files).
* Optional at compile time to aid merge request efforts.
* Flexible, expandable and compatible with modern graphics.
* It doesn't increase the hardware requirements, it expands the hardware range FG can run on. People with integrated GPUs (Intel HD etc) can run a Compositor with a single pass that renders directly to the screen like before, while people with more powerful cards can run a Compositor that implements deferred rendering, for example.

Unlike Rembrandt, the Compositor makes use of scene graph cameras
instead of viewer level cameras.

This allows CameraGroup to manage windows, near/far cameras and other
slaves without interfering with what is being rendered
(post-processing, shadows...).

The Compositor is in an usable state right now: it works but there are
no effects or pipelines developed for it. There are also some bugs and
features that don't work as expected because of some hardcoded
assumptions in the FlightGear Viewer code. Still, I think it's time to
announce it so people much more knowledgeable than me can point me in
the right direction to get this upstream and warn me about possible
issues and worries. :)

=== Aircraft Dialogs ===
Some of you may already know that the current tool to generate the dialogs ([[PUI]]) is going to disappear in the mid-future. After some (partially controversial) discussion, there seems now to be some support for the idea that canvas is a good tool to generate aircraft-specific dialogs in the future <ref>https://sourceforge.net/p/flightgear/mailman/flightgear-devel/thread/93862C87-0D3E-47BB-B169-8D3CBBF963B7%40kdab.com/#msg36194973</ref> (as it allows to tailor the dialog closely to the plane and also, canvas being canvas, the UI can smoothly mesh with the 3d models, so you can project a canvas checklist onto a 3d model in sim for instance rather than a popup window).

Thorsten would very much like to claim to be pioneering this approach, but in fact he believes the [[Extra EA-500|Extra-500 team]] is - look at the [[Extra_EA-500/failure_dialog|failure dialog of that plane]] where you can click the components you want to fail and you see what he means!

[[File:Extra500-Failuredialog-deice.png|right|thumb|500px|Extra 500 - failure dialog - de-ice]]

Anyway, Thorsten has started to roll out a few designs of his own and try to keep the tools fairly general so that they can be re-used by others- so here's the revised version of the Shuttle propellant dialog.

[[File:Propellant dlg02.jpg|thumb|right|an example of the detail dialog which allows to set levels of fuel and oxidizer separately (and the overview dialog shows the usable propellant then, i.e. the minimum of the two) - for aircraft, this would be somewhat simpler.]]

The general idea is to use semi-transparent 'content gauges' on a background raster image to show where the tank is located and how full it currently is - double-clicking any tank will bring up a detail window which allows to set the content (here propellant and oxidier separately, this is rocket fuel...) and also shows the current tank pressures and temperatures.
The whole thing can readily be applied on top of a different raster image with a different number of tanks - you just instance and position the labels and 'gauges' you need - in fact placement is probably what's going to take longest (at least for me).
The whole thing is currently in flux <ref>{{cite web
|url = https://forum.flightgear.org/viewtopic.php?p=326789&sid=c15d338facab18fb091aa0530f5dfa0f#p326789
|title = <nowiki> Aircraft-specific dialogs </nowiki>
|author = <nowiki> Thorsten </nowiki>
|date = Jan 24th, 2018
|added = Jan 24th, 2018
|script_version = 0.36
}}</ref>
If anyone wants to follow the development or use the code, it's here:
https://sourceforge.net/p/fgspaceshuttledev/code/ci/development/tree/Nasal/canvas/canvas_dialogs.nas

=== Plot2D ===

[[File:Oscilloscope.png|thumb|rleibner's new Oscilloscope addon is working.This screenshot shows the usual c172p "magnetos checking" Channel 1 (yellow) is '''rpm''' (100 rpm / div).Channel 2 (mauve) is '''magnetos''' (1 / div).Time sweep is 200 ms / div.The idea is to share it as an addon. Mainly to have some feedback about plot2D/graph.<ref>{{cite web |url = https://forum.flightgear.org/viewtopic.php?p=325929#p325929 |title = <nowiki> Re: Plot2D and graph helpers </nowiki> |author = <nowiki> rleibner </nowiki> |date = Jan 6th, 2018 |added = Jan 6th, 2018 |script_version = 0.36 }}</ref>]]

== 2017 ==
=== Vertical Situation Display ===
[[File:Rleibner-canvas-vsd-12-2017.png|thumb|rleibner is developing a graph class that works using local (customized) coordinates and calls the plot2D helpers (see below).For testing (and as exercise) he came up with a VSD (Vertical Situation Display): <ref>https://forum.flightgear.org/viewtopic.php?f=71&t=33457#p324637</ref>]]
rleibner is developing a graph class that works using local (customized) coordinates and calls the plot2D helpers (see below).
For testing (and as exercise) he came up with a VSD (Vertical Situation Display): <ref>https://forum.flightgear.org/viewtopic.php?f=71&t=33457#p324637</ref>

=== Plot2D Helpers ===
[[File:Plot2D.rectangle and grid.png|thumb]]

[[File:Plot2D.polyline.png|thumb|plot2D.polyline example]]

[[File:Graph examples.png|thumb|rleibner's Canvas plotting framework implemented in Nasal <ref>https://forum.flightgear.org/viewtopic.php?f=30&t=32882&start=90</ref>]]

'''Plot2D''' is nothing more than a collection of helpers that aims to facilitate the task of coding. It makes intensive use of the [[Canvas Nasal API|Canvas API]], a mandatory reference for those who intend to refine the result beyond what is offered by plot2D.<br />
It is assumed here that you already have a minimal knowledge about [[Canvas]].<br />
For now '''Plot2D''' resides in the '''SpokenGCA''' addon, but the idea is that in the future it could be included in the $FG-ROOT/Nasal/canvas directory.<br />

Continue reading at [[How to manipulate Canvas elements]] ...

=== FG1000 ===
Here is a little update o the G1000 emulation. Stuart has now got the key [[MapStructure]] layers in place, though they are not styled correctly for the '''G1000''' yet and Stuart would like to replace some of them (airspace in particular) with vector data, and started on the MFD architecture. For prototyping he hacked together a [[PUI]] dialog box, which speeds up development massively as it reloads all the Nasal code each time it's opened.

There's a screenshot of it here: [[File:Fg1000_mfd.jpg|thumb|right]]

There's also a wiki page of the current status here: http://wiki.flightgear.org/FG1000 Next steps are to get the MFD architecture in place - this will probably require some changes to Richard's generic [[Canvas MFD Framework|MFD]] to support buttons that don't change the MFD pages better. Stuart has not yet pushed this to fgdata - he'll wait until he's happy with the overall architectures so that there is a solid base for anyone else interested in helping out.<ref>{{cite web
|url = https://sourceforge.net/p/flightgear/mailman/message/36103513/
|title = <nowiki> [Flightgear-devel] FG1000 update </nowiki>
|author = <nowiki> Stuart Buchanan </nowiki>
|date = Nov 4th, 2017
|added = Nov 4th, 2017
|script_version = 0.40
}}</ref>
=== CanvasWidget and PUI ===
James pushed a change which changes how we integrate [[PUI]] into the renderer and other systems <ref>https://sourceforge.net/p/flightgear/flightgear/ci/804dc4e74ab921f196ca5e09eb7cd6de74b09c0d/</ref>; this makes our PUI usage more modular, so it can be enabled / disabled in a standard way. It also renders PUI via an FBO so we can use it safely (and scale it) on HiDPI screens, since PUI is too old to support a scaling factor as more modern UI toolkits would do. I’ve done a fair amount of testing, and everything seems to be working, but if you see any changes in how PUI reacts to mouse or key presses, or the appearance of things, please let James know via the issue or devel mailing list. It’s using the same code as it always did but starting from a slightly different place, both in terms of drawing and event handling. One temporary regression: right now CanvasWidget (the mechanism by which we include canvas content into PUI) is messed up because previously PUI had no alpha channel, so the canvas’s alpha was ignored.

With the new system, the alpha is actually being used, but this is not really desired - it shows up as a semi-transparent map background in the ‘Select airport’ airfield chart, and the Map-Canvas window at least. James thought he had a work-around for this, but the one he came up with is awkward to support on Windows, he still needs to think on a better solution, so in the meantime he pushed a hack so at least Windows still builds and runs <ref>https://sourceforge.net/p/flightgear/flightgear/ci/c1df6e9d1528fc2513c6f455f0c0ccc6ca74e34a/</ref>. (If your canvas content inside PUI has an opaque background, you’ll be fine, so one fix is just to adjust the Canvas code for those dialogs, but James would like to find a backwards compatible fix)<ref>{{cite web
|url = https://sourceforge.net/p/flightgear/mailman/message/36084254/
|title = <nowiki> [Flightgear-devel] PUI non-change, CanvasWidget appearance </nowiki>
|author = <nowiki> James Turner </nowiki>
|date = Oct 20th, 2017
|added = Oct 20th, 2017
|script_version = 0.40
}}</ref>

===MapStructure used by airports.xml ===
[[File:Airport-selection dialog updated to use MapStructure.png|thumb|Screenshot showing a the [[PUI]] based airports.xml dialog with an embedded [[Canvas]] widget feature a [[MapStructure]] based airport diagram developed by Stuart]]
Stuart has committed some changes <ref>https://sourceforge.net/p/flightgear/fgdata/ci/d84c527ca747dd6bbd9634507f0664ff3631bdef/</ref> to update the Select Airport dialog to use [[Canvas MapStructure]] Layers to display airport information, rather than the now deprecated map layers. The change should be largely transparent to end users - the only significant change is that your can display navigation symbols. This is all part of a long-term effort to provide the building blocks for a Garmin G1000 - these layers could be used for the airport display on the MFD, and could easily be combined with the APS layer to show a moving aircraft.<ref>{{cite web
|url = https://sourceforge.net/p/flightgear/mailman/message/36075357/
|title = <nowiki> [Flightgear-devel] Updated Select Airport dialog </nowiki>
|author = <nowiki> Stuart Buchanan </nowiki>
|date = Oct 13th, 2017
|added = Oct 13th, 2017
|script_version = 0.40
}}</ref>

=== Canvas Slippy Maps ===
[[File:StuartsSlippyMap1.png|thumb|Stuart pushed some changes to fgdata with OpenStreetMap, OpenAIP and VFRMap layers for the Canvas Map Layer system, which can be seen on the canvas map dialog. They use a generic Slippy Map OverlayLayer Map Layer. Additional web-based mapping can be trivially added by creating a new lcontroller. See Nasal/Canvas/map/OpenAIP.lcontroller for an example.I've also added a Web Mercator Projection to the Canvas Map support.The wiki will be updated shortly.<ref>{{cite web |url = https://forum.flightgear.org/viewtopic.php?p=319545#p319545 |title = <nowiki> Re: Canvas G1000 </nowiki> |author = <nowiki> stuart </nowiki> |date = Sep 28th, 2017 |added = Sep 28th, 2017 |script_version = 0.40 }}</ref>]]

[[File:StuartsSlippyMap2.png|thumb|Stuart pushed some changes to fgdata with OpenStreetMap, OpenAIP and VFRMap layers for the Canvas Map Layer system, which can be seen on the canvas map dialog. They use a generic Slippy Map OverlayLayer Map Layer. Additional web-based mapping can be trivially added by creating a new lcontroller. See Nasal/Canvas/map/OpenAIP.lcontroller for an example.I've also added a Web Mercator Projection to the Canvas Map support.The wiki will be updated shortly.<ref>{{cite web |url = https://forum.flightgear.org/viewtopic.php?p=319545#p319545 |title = <nowiki> Re: Canvas G1000 </nowiki> |author = <nowiki> stuart </nowiki> |date = Sep 28th, 2017 |added = Sep 28th, 2017 |script_version = 0.40 }}</ref>]]

[[File:StuartsSlippyMap3.png|thumb|MapStructure OpenAIP layer created by Stuart for the ongoing G1000 effort]]

[[File:StuartsSlippyMap4.png|thumb|MapStructure OSM (OpenStreetMap) layer created by Stuart for his ongoing G1000 effort]]

[[File:Slawek-stamen-maps.png|thumb|Regarding mailling list talk: https://sourceforge.net/p/flightgear/mailman/message/36059733/ and some information in G1000 canvas topic (https://forum.flightgear.org/viewtopic.php?f=71&t=32764There is commented out three different map styles (terrain + overlay, terrain, toner). One can apply this patch to get new tile rendering.<ref>{{cite web |url = https://forum.flightgear.org/viewtopic.php?p=319802#p319802 |title = <nowiki> Canvas MapLayer for OSM, OpenAIP, VFR Sectionals and other </nowiki> |author = <nowiki> slawekmikula </nowiki> |date = Oct 2nd, 2017 |added = Oct 2nd, 2017 |script_version = 0.40 }}</ref>]]

Stuart wants to build a set of Canvas MapStructure layers for a G1000 implementation - the canvas map UI is really just a way to display it.<ref>{{cite web
|url = https://sourceforge.net/p/flightgear/mailman/message/36059733/
|title = <nowiki> Re: [Flightgear-devel] Canvas MapLayer for OpenStreetMap, OpenAIP,
VFR Sectionals </nowiki>
|author = <nowiki> Stuart Buchanan </nowiki>
|date = Oct 1st, 2017
|added = Oct 1st, 2017
|script_version = 0.40
}}</ref>

* SimGear: https://sourceforge.net/p/flightgear/simgear/ci/a800189c25a3fb4610c1e36655940a95694c4a84/
* FGData: https://sourceforge.net/p/flightgear/fgdata/ci/85b7665c19ebaae02d746fef53f25f8d8974eb13/<ref>{{cite web
|url = https://forum.flightgear.org/viewtopic.php?p=319550#p319550
|title = <nowiki> Re: Canvas G1000 </nowiki>
|author = <nowiki> Hooray </nowiki>
|date = Sep 28th, 2017
|added = Sep 28th, 2017
|script_version = 0.40
}}</ref>

Stuart added some new Nasal Canvas MapLayers to support Slippy Maps, as used by most web-based mapping services such as openstreetmap. This allows us to display sectional charts (for the US - vfrmap.com), and airspace information (courtesy of openaip.org), as well as a openstreetmap data. The canvas Map dialog has been updated to support these layers. Map data is retrieved over http and cached locally.<ref>{{cite web
|url = https://sourceforge.net/p/flightgear/mailman/message/36056088/
|title = <nowiki> [Flightgear-devel] Canvas MapLayer for OpenStreetMap, OpenAIP,
VFR Sectionals </nowiki>
|author = <nowiki> Stuart Buchanan </nowiki>
|date = Sep 28th, 2017
|added = Sep 28th, 2017
|script_version = 0.40
}}</ref>

fgdata with OpenStreetMap, OpenAIP and VFRMap layers for the Canvas Map Layer system, which can be seen on the canvas map dialog. They use a generic Slippy Map OverlayLayer Map Layer. Additional web-based mapping can be trivially added by creating a new lcontroller. See Nasal/Canvas/map/OpenAIP.lcontroller for an example.
Stuart has also added a Web Mercator Projection to the Canvas Map support.<ref>{{cite web
|url = https://forum.flightgear.org/viewtopic.php?p=319545#p319545
|title = <nowiki> Re: Canvas G1000 </nowiki>
|author = <nowiki> stuart </nowiki>
|date = Sep 28th, 2017
|added = Sep 28th, 2017
|script_version = 0.40
}}</ref>

=== Canvas VSD / Vertical MapStructure Layers ===
{{See also|Howto:Implement a Vertical Situation Display in Nasal}}
A few years ago, Omega95 created a Canvas VSD [[File:VSD-prototype-by-omega95.png|right|250px]]<ref>{{cite web
|url = https://forum.flightgear.org/viewtopic.php?p=291908#p291908
|title = <nowiki> Re: Trying to experiment </nowiki>
|author = <nowiki> Hooray </nowiki>
|date = Aug 5th, 2016
|added = Aug 5th, 2016
|script_version = 0.40
}}</ref>

Recently, clm76 adapted Omega95's original Canvas VSD to the CitationX<ref>{{cite web
|url = https://forum.flightgear.org/viewtopic.php?p=319234#p319234
|title = <nowiki> Re: Spoken GCA </nowiki>
|author = <nowiki> clm76 </nowiki>
|date = Sep 23rd, 2017
|added = Sep 23rd, 2017
|script_version = 0.40
}}</ref>

[[File:Clm76-vsd-10-2017.png|thumb|clm76 adapted the Omega95's VSD to the CitationX :<ref>{{cite web |url = https://forum.flightgear.org/viewtopic.php?p=319234#p319234 |title = <nowiki> Re: Spoken GCA </nowiki> |author = <nowiki> clm76 </nowiki> |date = Sep 23rd, 2017 |added = Sep 23rd, 2017 |script_version = 0.40 }}</ref>]]

=== Canvas + Effects goes Deferred Rendering ===
Icecode GL has been experimenting with effects/shaders support for Canvas and got something kind of dirty and primitive but it works:

[[File:Canvas+Effects vs deferred.png|thumb|been experimenting with effects/shaders support for Canvas and Icecode GL got something kind of dirty and primitive but it works]]

It works similarly to how Rembrandt does its buffers. There is a new texture type called "canvas" that allows shaders to access any canvas texture via a texture unit, just like you'd access a normal texture from the hard drive. This removes (most) limitations of addPlacement, which can only substitute the "base" texture (unit 0). The posibilities are endless, it just needs some care and work. At the moment we could have shadow mapping outside Rembrandt just by creating a new view placed at the Sun and make it render the depth buffer to a canvas. Then every ALS shader could access this canvas and do the shadow comparison thingy. Planar reflections in the water should be kind of trivial as well, it'd just require the model-view matrix to be multiplied by a reflection matrix and the water shader could just paste the result over the water surface (with some more fancy calculations to make it pretty of course).<ref>{{cite web
|url = https://forum.flightgear.org/viewtopic.php?p=318662#p318662
|title = <nowiki> Re: Canvas:View development </nowiki>
|author = <nowiki> Icecode GL </nowiki>
|date = Sep 11th, 2017
|added = Sep 11th, 2017
|script_version = 0.40
}}</ref>

=== Canvas & Slave Cameras ===
{{See also|Howto:Canvas View Camera Element}}

[[File:Canvas-view-element-prototype-by-icecode gl.png|thumb|upright|[[Canvas]] gui dialog with a custom canvas element to display view manager views (based on code prototyped by F-JJTH)]]

[[File:F-JJTH-SlavedCams-Instrument-09-2017-one.png|thumb|First screenshot created by Alant, view from the rear cockpit of TSR2, showing the the custom "camera-display" prototyped by F-JJTH, just to the left of the moving map.Known issue: despite flying more or less straight and level, the image camera point can be seen to jump around between screenshots. <ref>{{cite web |url = https://forum.flightgear.org/viewtopic.php?p=317486#p317486 |title = <nowiki> Re: Gear view in cockpit computer </nowiki> |author = <nowiki> Alant </nowiki> |date = Aug 26th, 2017 |added = Aug 26th, 2017 |script_version = 0.40 }}</ref>]]

[[File:F-JJTH-SlavedCams-Instrument-09-2017-two.png|thumb|Second screenshot created by Alant, view from the rear cockpit of TSR2, showing the the custom "camera-display" prototyped by F-JJTH, just to the left of the moving map.Known issue: despite flying more or less straight and level, the image camera point can be seen to jump around between screenshots. <ref>{{cite web |url = https://forum.flightgear.org/viewtopic.php?p=317486#p317486 |title = <nowiki> Re: Gear view in cockpit computer </nowiki> |author = <nowiki> Alant </nowiki> |date = Aug 26th, 2017 |added = Aug 26th, 2017 |script_version = 0.40 }}</ref>]]

Former FlightGear core developer F-JJTH shared a patch <ref>{{cite web
|url = https://forum.flightgear.org/viewtopic.php?p=317448#p317448
|title = <nowiki> Re: Gear view in cockpit computer </nowiki>
|author = <nowiki> Hooray </nowiki>
|date = Aug 26th, 2017
|added = Aug 26th, 2017
|script_version = 0.40
}}</ref> implementing a proof-of-concept to render an arbitrary slave view to a FBO/RTT using a new dedicated "camera-display" instrument. This would be the kind of functionality required to implement many interesting features that cannot currently be added easily; Rear view mirrors in fighters could become a reality, as well as camera displays in SAR helicopters, outside views in airliners, backing view displays in cars etc.<ref>{{cite web
|url = https://forum.flightgear.org/viewtopic.php?p=317462#p317462
|title = <nowiki> Re: Gear view in cockpit computer </nowiki>
|author = <nowiki> Johan G </nowiki>
|date = Aug 26th, 2017
|added = Aug 26th, 2017
|script_version = 0.40
}}</ref>

The patch seems not to break anything else, and does nothing unless the aircraft side code is added. It is therefore reasonably safe to add the patch to your working copy of FG. No git branch expertise is required.<ref>{{cite web
|url = https://forum.flightgear.org/viewtopic.php?p=317493#p317493
|title = <nowiki> Re: Gear view in cockpit computer </nowiki>
|author = <nowiki> Alant </nowiki>
|date = Aug 26th, 2017
|added = Aug 26th, 2017
|script_version = 0.40
}}</ref>

Once the patch is applied and the binary rebuilt, all that is needed is to add the new camera-display to an existing cockpit panel:

<syntaxhighlight lang="xml">
<camera-display>
<name>cd</name>
<texture></texture>
<enabled type="bool">true</enabled>
<view-number>0</view-number>
</camera-display>
</syntaxhighlight>

For view configuratoin, it's using the standard view-manager interface, so you primarily need to set the view-number property to change the view (untested, feedback is just based on looking at the patch in question).
Specifically, when running the patched fgfs binary, look for: '''/instrumentation/camera-display''' and the '''view-number''' property underneath<ref>{{cite web
|url = https://forum.flightgear.org/viewtopic.php?p=317488#p317488
|title = <nowiki> Re: Gear view in cockpit computer </nowiki>
|author = <nowiki> Hooray </nowiki>
|date = Aug 26th, 2017
|added = Aug 26th, 2017
|script_version = 0.40
}}</ref>

The current state is... well, it "works" ;-)
However there are some bugs:

* The image jumps all over the place when the aircraft is moving.
* The colours are wrong.<ref>{{cite web
|url = https://forum.flightgear.org/viewtopic.php?p=317475#p317475
|title = <nowiki> Re: Gear view in cockpit computer </nowiki>
|author = <nowiki> Alant </nowiki>
|date = Aug 26th, 2017
|added = Aug 26th, 2017
|script_version = 0.40
}}</ref>

# The colours are wrong with Rembrandt. It looks as if the wrong buffer is being used.
# Jumping around is the same with and without Rembrandt.<ref>{{cite web
|url = https://forum.flightgear.org/viewtopic.php?p=317486#p317486
|title = <nowiki> Re: Gear view in cockpit computer </nowiki>
|author = <nowiki> Alant </nowiki>
|date = Aug 26th, 2017
|added = Aug 26th, 2017
|script_version = 0.40
}}</ref>

The jumping around effect seems to be in all views. The control tower view jumps back and forward, showing the whole tower at times.<ref>{{cite web
|url = https://forum.flightgear.org/viewtopic.php?p=317489#p317489
|title = <nowiki> Re: Gear view in cockpit computer </nowiki>
|author = <nowiki> Alant </nowiki>
|date = Aug 26th, 2017
|added = Aug 26th, 2017
|script_version = 0.40
}}</ref>

before looking at some of our most advanced use-cases, it's best to tinker with a really simple scenario, to see how well this works, and what needs to be polished.<ref>{{cite web
|url = https://forum.flightgear.org/viewtopic.php?p=317487#p317487
|title = <nowiki> Re: Gear view in cockpit computer </nowiki>
|author = <nowiki> Hooray </nowiki>
|date = Aug 26th, 2017
|added = Aug 26th, 2017
|script_version = 0.40
}}</ref>

if anybody is interested in working out what is missing or what can be improved, we should review working features doing similar things, e.g. the screenshot/streaming handlers or the camera setup routines used by CameraGroup.cxx itself.<ref>{{cite web
|url = https://forum.flightgear.org/viewtopic.php?p=317477#p317477
|title = <nowiki> Re: Gear view in cockpit computer </nowiki>
|author = <nowiki> Hooray </nowiki>
|date = Aug 26th, 2017
|added = Aug 26th, 2017
|script_version = 0.40
}}</ref>

The patch itself seems overlapping with Zan's original "new-cameras" effort, as mentioned at: [[Canvas Development#Supporting Cameras]]
If this patch should work well enough, it would probably make sense to integrate it with the Canvas system to come up with a dedicated "camera" element for the Canvas system, that would be configurable using the format/properties used by the view manager: [[Howto:Configure views in FlightGear]]
At that point, it would actually be a terrific idea to review Zan's original patches and see if any of the features there could/should be integrated with the new Canvas::Camera element - like you say, once this is properly working, "the sky is the limit" (or not even that, think shuttle cams)<ref>{{cite web
|url = https://forum.flightgear.org/viewtopic.php?p=317466#p317466
|title = <nowiki> Re: Gear view in cockpit computer </nowiki>
|author = <nowiki> Hooray </nowiki>
|date = Aug 26th, 2017
|added = Aug 26th, 2017
|script_version = 0.40
}}</ref>

Thus, the patch needs some TLC - however, it's definitely a very solid foundation, and very compelling as a prototype, especially given that the patch is pretty lightweight.

Much of the OSG machinery to set up the FBO/RTT (render to texture) is overlapping with Canvas functionality, so we could do away with that by using a dedicated Canvas element (which may fix some issues, e.g. colors being off).

Besides, if/when we actually use the approach used by Torsten's screenshot handler routines (mongoose/Phi), the "jumping" may also be gone (just a guess).
At this point, we need to get more people involved who are able to patch/rebuild sg/fg from source and test these patches, so that we can come up with a team of folks to help with testing/developing. Hooray can certainly help with the Canvas side of this, which means that the FBO/RTT setup routines can be simplified, and he can help turn the whole thing into a dedicated Canvas "camera" element.

<ref>{{cite web
|url = https://forum.flightgear.org/viewtopic.php?p=317490#p317490
|title = <nowiki> Re: Gear view in cockpit computer </nowiki>
|author = <nowiki> Hooray </nowiki>
|date = Aug 26th, 2017
|added = Aug 26th, 2017
|script_version = 0.40
}}</ref>

=== G1000 & MapStructure improvements ===
{{Main article|FG1000}}

As of 09/2017, Stuart started making some tentative steps towards a full Garmin [[G1000]] simulation, he started with the excellent xkv1000 as a starting point, particularly for the PFD which very closely mirrors the G1000.

For the MFD he's planning to use the [[Canvas MapStructure]] layers (obviously).
One area he is going to have to develop is tiled mapping, which the [[MapStructure]] in fgdata doesn't currently support as a layer.

Stuart's thoughts are:

# Create an OverlayLayer layer with a controller that is analogous to the SymbolLayer, but likely with a simple update method rather than SearchCmd, and no .symbol equivalent
# Convert the tiled map example from the wiki, but also other layers such as a compass rose, airport diagram, lat/lon grid.

Stuart is currently undecided on how to handle the projection - whether to have the layer itself have to interpret the centerpoint of the map and scale, and then make a projection itself, or to provide it from the Map. The latter would undoubtably be cleaner, but for something like a tiled map he suspects that the management will need to be quite low down the stack.<ref>{{cite web
|url = https://forum.flightgear.org/viewtopic.php?p=317013#p317013
|title = <nowiki> Canvas G1000 </nowiki>
|author = <nowiki> stuart </nowiki>
|date = Aug 21st, 2017
|added = Aug 21st, 2017
|script_version = 0.40
}}</ref>

Stuart is getting to grips with the Canvas MapLayer stuff, and in particular rendering layers from a map service. One layer he is wanting to add is airspace information, so it's very good news that this is available. From the looks of things Stuart may just be able to plug in the Slippy Tile URLs and render all the airspace in-sim in a Canvas map.<ref>{{cite web
|url = https://sourceforge.net/p/flightgear/mailman/message/36034923/
|title = <nowiki> Re: [Flightgear-devel] New MultiPlayer map server based on nodejs </nowiki>
|author = <nowiki> Stuart Buchanan </nowiki>
|date = Sep 12th, 2017
|added = Sep 12th, 2017
|script_version = 0.40
}}</ref>

=== Property I/O ===
{{See also|Howto:Canvas Path Benchmarking}}

As a first step towards [[Canvas_News#Moving_map.2FRNAV_discussion|developing a G1000]], Stuart Buchanan has been looking at Nasal property read/write performance, as he understands that this is a bottleneck for developing complex Canvas applications.<ref>{{cite web
|url = https://sourceforge.net/p/flightgear/mailman/message/35974946/
|title = <nowiki> [Flightgear-devel] Nasal property lookup performance </nowiki>
|author = <nowiki> Stuart Buchanan </nowiki>
|date = Jul 31st, 2017
|added = Jul 31st, 2017
|script_version = 0.40
}}</ref>

For well-organized code (aka writing only when needed, organizing the displays in suitable groups, staggered updates...), it's going to be fast enough. For a straightforward approach to complicated displays probably not. A thousand properties sounds a lot, but every update in translation is already 2 properties, combined with a visible flag and color information you're down to 166 elements you can update already. If each of them is driven by reading a value from the tree you're losing even more. Generally, if there is a way of making either method faster, it would affect performance in a positive way all over Nasal scripting because currently property I/O is in my view the largest bottleneck (especially of canvas).<ref>{{cite web
|url = https://sourceforge.net/p/flightgear/mailman/message/35975339/
|title = <nowiki> Re: [Flightgear-devel] Nasal property lookup performance </nowiki>
|author = <nowiki> Thorsten Renk </nowiki>
|date = Aug 1st, 2017
|added = Aug 1st, 2017
|script_version = 0.40
}}</ref>

low-hanging fruit in the canvas API:
* add more calls like updateText (updateTranslation, updateRotation,...) which check whether the property to be written has changed at all against a Nasal record before actually doing property I/O
* make the updateXXX methods store the node reference and use that rather than construct it afresh

If the test suite numbers hold up in reality, this ought to give a factor 2 to <few hundred> (dependent on how often the argument actually has to be written - at least Thorsten was able to write 50 million numbers into a Nasal array much faster than 50.000 numbers into properties).<ref>{{cite web
|url = https://sourceforge.net/p/flightgear/mailman/message/35976562/
|title = <nowiki> Re: [Flightgear-devel] Nasal property lookup performance </nowiki>
|author = <nowiki> Thorsten Renk </nowiki>
|date = Aug 1st, 2017
|added = Aug 1st, 2017
|script_version = 0.40
}}</ref>

it’s easy to add native helpers to Canvas to set some properties from code directly, rather than using the canvas.nas wrappers which then use props.nas internally. This could bypass a whole ton of Nasal if that’s the issue. Of course this code will still have to update properties from C++, so we should rather do the analysis first to see where the slowness occurs, since this could either be a very big win, or completely pointless based on that measurement.<ref>{{cite web
|url = https://sourceforge.net/p/flightgear/mailman/message/35976398/
|title = <nowiki> Re: [Flightgear-devel] Nasal property lookup performance </nowiki>
|author = <nowiki> James Turner </nowiki>
|date = Aug 1st, 2017
|added = Aug 1st, 2017
|script_version = 0.40
}}</ref>

=== Moving map/RNAV discussion ===
{{See also|Complex Canvas Avionics}}

The airspace system is in the process of changing drastically<ref>{{cite web
|url = https://sourceforge.net/p/flightgear/mailman/message/35924395/
|title = <nowiki> [Flightgear-devel] RFD: FlightGear and the changing state of air
navigation </nowiki>
|author = <nowiki> David Megginson </nowiki>
|date = Jul 3rd, 2017
|added = Jul 3rd, 2017
|script_version = 0.40
}}</ref>

and there's an interesting discussion that was started by David Megginson regarding implementing G1000-type systems on the mailing list:
[https://sourceforge.net/p/flightgear/mailman/flightgear-devel/thread/CAKor_TGugT%2Be%3DQhdNBqWq3Pn%2BCEq6iLZsgaB7HmiU%2BBoDK0vxQ%40mail.gmail.com/#msg35924395 https://sourceforge.net/p/flightgear/mailman/flightgear-devel/thread/CAKor_TGugT%2Be%3DQhdNBqWq3Pn%2BCEq6iLZsgaB7HmiU%2BBoDK0vxQ%40mail.gmail.com/#msg35924395]<ref>{{cite web
|url = https://forum.flightgear.org/viewtopic.php?p=313697#p313697
|title = <nowiki> Re: zkv1000 reborn </nowiki>
|author = <nowiki> stuart </nowiki>
|date = Jul 4th, 2017
|added = Jul 4th, 2017
|script_version = 0.40
}}</ref>

When you're flying an IFR approach with a GPS navigator, you can use RNAV for the transitions, but need to switch to the ground ILS transmitter for the actual approach (they both use the same CDI on many planes, so it's easy to miss). The GTN 650 that I'm installing in my plane will switch CDI mode automatically under certain conditions, but it's not guaranteed. In the past, people could practice the hell out of these kinds of details in FlightGear (tuning, twisting, and identifying all the navaids, adding crosswind corrections, etc) so that they were habits when I flew them for real, but we can't practice RNAV procedures like this (or many others).<ref>{{cite web
|url = https://sourceforge.net/p/flightgear/mailman/message/35926937/
|title = <nowiki> Re: [Flightgear-devel] RFD: FlightGear and the changing state of
air navigation </nowiki>
|author = <nowiki> David Megginson </nowiki>
|date = Jul 4th, 2017
|added = Jul 4th, 2017
|script_version = 0.40
}}</ref>

this is something we need to address, as our GA aircraft will otherwise become more and more old-fashioned.<ref>{{cite web
|url = https://sourceforge.net/p/flightgear/mailman/message/35925226/
|title = <nowiki> Re: [Flightgear-devel] RFD: FlightGear and the changing state of
air navigation </nowiki>
|author = <nowiki> Stuart Buchanan </nowiki>
|date = Jul 3rd, 2017
|added = Jul 3rd, 2017
|script_version = 0.40
}}</ref>

FlightGear will still be great for people who want to practice the mechanical parts of flying (e.g. crosswind wheel landings in a Cub), but will slip further and further behind for people who want to use it for real IFR practice.<ref>{{cite web
|url = https://sourceforge.net/p/flightgear/mailman/message/35927088/
|title = <nowiki> Re: [Flightgear-devel] RFD: FlightGear and the changing state of
air navigation </nowiki>
|author = <nowiki> David Megginson </nowiki>
|date = Jul 4th, 2017
|added = Jul 4th, 2017
|script_version = 0.40
}}</ref>

zakh on the forum has been developing a Garmin G1000 clone called thekv1000: https://forum.flightgear.org/viewtopic.php?f=14&t=32056 <ref>{{cite web
|url = https://sourceforge.net/p/flightgear/mailman/message/35925226/
|title = <nowiki> Re: [Flightgear-devel] RFD: FlightGear and the changing state of
air navigation </nowiki>
|author = <nowiki> Stuart Buchanan </nowiki>
|date = Jul 3rd, 2017
|added = Jul 3rd, 2017
|script_version = 0.40
}}</ref>

the G1000 has multiple pages of data with data entry for flightplans etc. Stuart is sure there is a lot that has been learned by the Shuttle team that can be passed on as "best practise". The Route Manager should be able to handle most of the "magenta line" tasks, but it may be that the more complicated routing such as the RF approach, fly-by vs fly-over requires some new autopilot coding as you describe.<ref>{{cite web
|url = https://sourceforge.net/p/flightgear/mailman/message/35925369/
|title = <nowiki> Re: [Flightgear-devel] RFD: FlightGear and the changing state of
air navigation </nowiki>
|author = <nowiki> Stuart Buchanan </nowiki>
|date = Jul 3rd, 2017
|added = Jul 3rd, 2017
|script_version = 0.40
}}</ref>

The MFD framework that is used on the Shuttle is more than capable of supporting a most of the requirements; Canvas is capable of rendering the displays. So it's possible to do this<ref>{{cite web
|url = https://sourceforge.net/p/flightgear/mailman/message/35927653/
|title = <nowiki> Re: [Flightgear-devel] RFD: FlightGear and the changing state of
air navigation </nowiki>
|author = <nowiki> Richard Harrison </nowiki>
|date = Jul 4th, 2017
|added = Jul 4th, 2017
|script_version = 0.40
}}</ref>

A number of contributors expressed concerns regarding the performance of the Canvas system when it comes to implementing sophisticated avoinics like G1000-style systems. However, the fact that there are people who code canvas like there's no tomorrow and update 10 elements where an update of the group position would do the trick at a fraction of the cost doesn't mean that canvas or Nasal are slow - it means inefficient code is slow, and that's just as true for C++. Nasal as such is fast, and compared with the cost of rendering the terrain, rendering a canvas display is fast on the GPU (you can test by rendering but not updating a canvas display), and unless you're doing something very inefficient, calculating a display but not writing it to the property tree is fast (you can test this by disabling the write commands). It's the property I/O which you need to structure well, and then canvas will run fast. And of course the complexity of your underlying simulation costs - if you run a thermal model underneath to get real temperature reading, it costs more than inventing the numbers. But that has nothing to do with canvas.<ref>{{cite web
|url = https://sourceforge.net/p/flightgear/mailman/message/35926343/
|title = <nowiki> Re: [Flightgear-devel] RFD: FlightGear and the changing state of
air navigation </nowiki>
|author = <nowiki> Thorsten Renk </nowiki>
|date = Jul 4th, 2017
|added = Jul 4th, 2017
|script_version = 0.40
}}</ref>

Structured in a reasonable way (i.e. minimiing property I/O in update cycles, avoiding canvas pitfalls which trigger high performance needs etc. ) canvas is pretty fast (kind of reminds me of the old 'Nasal is slow' discussions... it's still the same things which are slow, except canvas hides it behind some abstraction - understand property I/O, and it'll run fast)<ref>{{cite web
|url = https://sourceforge.net/p/flightgear/mailman/message/35925540/
|title = <nowiki> Re: [Flightgear-devel] RFD: FlightGear and the changing state of
air navigation </nowiki>
|author = <nowiki> Thorsten Renk </nowiki>
|date = Jul 3rd, 2017
|added = Jul 3rd, 2017
|script_version = 0.40
}}</ref>

The G1000 is a fairly significant piece of computer hardware that we're going to emulate. It's not going to be "free" particularly for those on older hardware that's already struggling. However, hopefully we can offload a chunk of the logic (route management, autopilot/flight director) to the core, and do things like offline generation of terrain maps to minimie the impact.<ref>{{cite web
|url = https://sourceforge.net/p/flightgear/mailman/message/35926745/
|title = <nowiki> Re: [Flightgear-devel] RFD: FlightGear and the changing state of
air navigation </nowiki>
|author = <nowiki> Stuart Buchanan </nowiki>
|date = Jul 4th, 2017
|added = Jul 4th, 2017
|script_version = 0.40
}}</ref>

For starters, Stuart is hoping to to optimize the property access and become more familiar with the Canvas C++ code so that he can help bridge the cap between core and Canvas client developers. He thinks James has some thoughts on the Canvas C++, so he'll want to coordinate with him as well.<ref>{{cite web
|url = https://forum.flightgear.org/viewtopic.php?p=313787#p313787
|title = <nowiki> Re: zkv1000 reborn </nowiki>
|author = <nowiki> stuart </nowiki>
|date = Jul 6th, 2017
|added = Jul 6th, 2017
|script_version = 0.40
}}</ref>

One of the ideas raised by David is, should there maybe be a separate project to build an embeddable GPS navigator with different faces/UIs (and a default standalone front end)? As others have mentioned, a lot of the backend logic is the same, like doing a gradual transition from RNAV to Localiser on intercept to avoid a sudden jolt in the A/P, or calculating a turn past a fly-by waypoint. Again, that would be a way to join forces with other Sim dev communities. <ref>{{cite web
|url = https://sourceforge.net/p/flightgear/mailman/message/35929948/
|title = <nowiki> Re: [Flightgear-devel] RFD: FlightGear and the changing state of
air navigation </nowiki>
|author = <nowiki> David Megginson </nowiki>
|date = Jul 5th, 2017
|added = Jul 5th, 2017
|script_version = 0.40
}}</ref>

if we wanted to build a tablet-based emulator ourselves, we could at least join forces with the FSX and X-Plane communities to do it to grow up the pool of talent.<ref>{{cite web
|url = https://sourceforge.net/p/flightgear/mailman/message/35927243/
|title = <nowiki> Re: [Flightgear-devel] RFD: FlightGear and the changing state of
air navigation </nowiki>
|author = <nowiki> David Megginson </nowiki>
|date = Jul 4th, 2017
|added = Jul 4th, 2017
|script_version = 0.40
}}</ref>

=== Groups and Colors ===
Thorsten learned something rather important about canvas: After doing canvas a while, most of us love the concept to suitably group things and then translate or hide the whole group, which is a very performance-friendly way to get the job done compared with moving all elements.

Thorsten had the situation that the Shuttle HUD has several de-clutter levels which are progressively hidden as the de-clutter function is used. So, he introduced dc0 to dc3 as the groups and operate with selective setVisible() on them according to chosen de-clutter level.

Doing brightness adjustment of the HUD by setting color on the group (specifically the alpha channel).

Unlike translations, rotations or visible statements acting on the top level of the group, this one seems to be passed recursively down the child elements, leading to a huge property I/O.

Anyway, if you know what it does, it's a very useful function still - just it can't be used in a performance-critical place, and it should not be confused with performance-friendly group operations.<ref>{{cite web
|url = https://forum.flightgear.org/viewtopic.php?p=307073#p307073
|title = <nowiki> Color and groups - beware! </nowiki>
|author = <nowiki> Thorsten </nowiki>
|date = Mar 16th, 2017
|added = Mar 16th, 2017
|script_version = 0.40
}}</ref>

=== Canvas GUI ===
James is planning a bit of work in the Canvas GUI/widgets area but in the medium term (mid 2017), he wouldn't recommend making lots of extensions to the current Canvas GUI toolkit because he wants to give the whole Canvas-GUI architecture a review and sanity-check first. For the time being, he has no idea if this will be compatible or incompatible with the existing GUI controls, or even be successful. <ref>{{cite web
|url = https://sourceforge.net/p/flightgear/mailman/message/35591369/
|title = <nowiki> Re: [Flightgear-devel] fgplot / currently active canvas developers? </nowiki>
|author = <nowiki> James Turner </nowiki>
|date = Jan 8th, 2017
|added = Jan 8th, 2017
|script_version = 0.40
}}</ref>

Hhis intuition is the current style system is overkill, but that the layout code will need some enhancements. So he would avoid both those areas for now. Adding missing widget types is probably safe, but if you propose them here we can discuss their API to hopefully keep it stable even if the implementation changes.<ref>{{cite web
|url = https://sourceforge.net/p/flightgear/mailman/message/35610051/
|title = <nowiki> Re: [Flightgear-devel] fgplot / currently active canvas developers? </nowiki>
|author = <nowiki> James Turner </nowiki>
|date = Jan 17th, 2017
|added = Jan 17th, 2017
|script_version = 0.40
}}</ref>

=== Skia talks ===
James announced he wants to replace the vector drawing routines with another package which was designed with SIMD in mind<ref>{{cite web
|url = https://forum.flightgear.org/viewtopic.php?p=302558#p302558
|title = <nowiki> Re: Simgear compilation failure </nowiki>
|author = <nowiki> erik </nowiki>
|date = Jan 3rd, 2017
|added = Jan 3rd, 2017
|script_version = 0.40
}}</ref>

Blend2D is quite amazing for a technical point of view: it compiles native CPU code (including SIMD) for every draw operation using a JIT compiler.<ref>{{cite web
|url = https://sourceforge.net/p/flightgear/mailman/message/35631656/
|title = <nowiki> Re: [Flightgear-devel] Canvas-svg </nowiki>
|author = <nowiki> Erik Hofman </nowiki>
|date = Jan 28th, 2017
|added = Jan 28th, 2017
|script_version = 0.40
}}</ref>

The idea is to use Skia (from Chrome), actually, since it has software and hardware backends. This would allow switching based on which gives better performance on a given machine, and easy porting to other devices, such as Android. The remote-canvas code is a proof-of-concept for this, the aim would be to use the same protocol to render the canvases in different threads.<ref>{{cite web
|url = https://sourceforge.net/p/flightgear/mailman/message/35630367/
|title = <nowiki> [Flightgear-devel] Canvas-svg </nowiki>
|author = <nowiki> James Turner </nowiki>
|date = Jan 27th, 2017
|added = Jan 27th, 2017
|script_version = 0.40
}}</ref>

After reviewing Skia (including reading the sources) and it seems like a very promising fit, albeit with the caveat that it is kind of huge. Blend2D looks pretty good but less mature than Skia, and most importantly, lacks a hardware renderer which James thinks is critical to support devices such as the Raspberry Pi and cheap Android tablets, which James expects to be a very good target for the remote canvas (an RPi driving a wide-screen panel via HDMI could do both the PFD and ND of a Boeing/Airbus setup, but that’s 1920 x 1080 pixels which is too much to fill in software at 60Hz) Anyway, at this point the code is small enough that experimenting with one renderer or another (Cairo also) is probably a weekend’s hacking, if anyone cared to try. James is currently working on hardware acceleration using QtQuick, since we already have Qt as a dependency.<ref>{{cite web
|url = https://sourceforge.net/p/flightgear/mailman/message/35631079/
|title = <nowiki> Re: [Flightgear-devel] Canvas-svg </nowiki>
|author = <nowiki> James Turner </nowiki>
|date = Jan 27th, 2017
|added = Jan 27th, 2017
|script_version = 0.40
}}</ref>

== 2016 ==

=== SIMD ===
{{Main article|SIMD Support}}
Erik is experimenting with streamlined Canvas rendering using Single Instruction Multiple Data (SIMD) instructions which is able to calculate on 4 floating poit variables simultaneously (e.g 3 or 4 value vectors). For the F-16 map this gives a speedup from 12+ seconds delay rendering at the first select down to 6 seconds delay.<ref>{{cite web
|url = https://sourceforge.net/p/flightgear/mailman/message/35555294/
|title = <nowiki> [Flightgear-devel] Canvas rendering speed </nowiki>
|author = <nowiki> Erik Hofman </nowiki>
|date = Dec 16th, 2016
|added = Dec 16th, 2016
|script_version = 0.40
}}</ref> <ref>{{cite web
|url = https://sourceforge.net/p/flightgear/mailman/message/35555306/
|title = <nowiki> Re: [Flightgear-devel] Canvas rendering speed </nowiki>
|author = <nowiki> Erik Hofman </nowiki>
|date = Dec 16th, 2016
|added = Dec 16th, 2016
|script_version = 0.36
}}</ref>

A few users have reported a noticeable increase in framerate on their computers, e.g. on some desktop the framerate has doubled<ref>{{cite web
|url = https://sourceforge.net/p/flightgear/mailman/message/35555950/
|title = <nowiki> Re: [Flightgear-devel] Canvas rendering speed </nowiki>
|author = <nowiki> Alan Teeder </nowiki>
|date = Dec 16th, 2016
|added = Dec 16th, 2016
|script_version = 0.36
}}</ref>.

SSE and NEON work best when considered in the design stage. Adding it afterwards is always suboptimal. Thus, Erik might still update it in a place or two but this work isn't intended to detract from adding Skia.<ref>{{cite web
|url = https://sourceforge.net/p/flightgear/mailman/message/35556369/
|title = <nowiki> Re: [Flightgear-devel] Canvas rendering speed </nowiki>
|author = <nowiki> Erik Hofman </nowiki>
|date = Dec 17th, 2016
|added = Dec 17th, 2016
|script_version = 0.36
}}</ref>

=== Porting the legacy HUD ===
James is planning to port the C++ HUD to use Canvas for its rendering soon (next few months), but he plans to keep XML compatibility (so aircraft don't see any change) and will keep the placement logic relative to the view, for the same reason. <ref>{{cite web
|url = https://forum.flightgear.org/viewtopic.php?p=301277#p301277
|title = <nowiki> Re: Pitfalls of canvas HUDs </nowiki>
|author = <nowiki> zakalawe </nowiki>
|date = Dec 15th, 2016
|added = Dec 15th, 2016
|script_version = 0.40
}}</ref>

=== 2D Panels ===

James is working towards migrating 2D panels to use the Canvas<ref>https://sourceforge.net/p/flightgear/mailman/message/35623408/</ref>.

This step was inspired by a discussion that originally took place on the devel list, i.e. we should move the 2D panel and HUD rendering over to this approach, since that would get rid of all the legacy OpenGL code besides the GUI. <ref>https://sourceforge.net/p/flightgear/mailman/message/29584988/</ref>

Moving the HUD to use the Canvas would be a great step from his point of view, since it and 2D panels (which he is happy to write the convert for!) are the last places besides the UI which make raw OpenGL calls, and hence would benefit from moving to the Canvas (and thus, to use OSG internally) <ref>https://sourceforge.net/p/flightgear/mailman/message/30058187/</ref>

The original goal was to identify common requirements to seee how we manage XML / property-list file processing in a nice way, to support the various formats we want to create canvas elements from - GUI dialogs, 2D panels and HUDs.<ref>https://sourceforge.net/p/flightgear/mailman/message/29588419/</ref>

James is planning in the next couple of weeks to port the panel code to generate Canvas elements, and then submit my fgcanvas utility to render any Canvas remotely, That code currently users software rendering (too slow for the RaspberryPi he expects), but upgrading the code to use OpenGL ES2 rendering is next on his todo-list so he can fun on Android / iOS devices as well as Raspbery Pi. If you’re interested in working on that please let him know, he would be glad of the help.<ref>https://sourceforge.net/p/flightgear/mailman/message/35552824/</ref>

James has done most of the work to port the 2D panels to use Canvas in an experimental branch<ref>https://sourceforge.net/p/flightgear/mailman/message/35691472/</ref>, and will do the C++ HUD next, and hence is creating Canvas elements bypassing the Nasal API.<ref>{{cite web
|url = https://sourceforge.net/p/flightgear/mailman/message/35574596/
|title = <nowiki> Re: [Flightgear-devel] Observation about the Canvas Z-ordering </nowiki>
|author = <nowiki> James Turner </nowiki>
|date = Dec 29th, 2016
|added = Dec 29th, 2016
|script_version = 0.36
}}</ref>

=== Skia backend ===
James is also currently looking at making a Skia backend for the Canvas (to replace Shiva, making a solution using Skia ([https://skia.org https://skia.org]) as the backend, because this would give good performance via its OpenGL backend, make people who don’t want to use Qt happier, and could also replace the OSG rendering of the Canvas within FlightGear itself, allowing us to ditch ShivaVG (which is unmaintained) and probably improve performance substantially. (Skia can do SSE3/NEON optimised software rendering in a background thread, so Canvas wouldn’t eat into our OSG / triangle budget)<ref>{{cite web
|url = https://forum.flightgear.org/viewtopic.php?p=300990#p300990
|title = <nowiki> Remote canvas utility </nowiki>
|author = <nowiki> zakalawe </nowiki>
|date = Dec 10th, 2016
|added = Dec 10th, 2016
|script_version = 0.40
}}</ref>), and Skia already has quite intensive SSE/NEON optimisations, in addition to an optimised OpenGL render which he expects to be substantially more performant than the current OSG Node/Drawable hierarchy.<ref>{{cite web
|url = https://sourceforge.net/p/flightgear/mailman/message/35555702/
|title = <nowiki> Re: [Flightgear-devel] Canvas rendering speed </nowiki>
|author = <nowiki> James Turner </nowiki>
|date = Dec 16th, 2016
|added = Dec 16th, 2016
|script_version = 0.40
}}</ref>

== References ==
{{Appendix}}

OpenGL performance

2023-11-28T14:05:58Z

MariuszXC: added entry for: NVIDIA GTX 1060 6GB + Intel Core i5-11600K @ 3.90GHz, driver ver. 535.129.03

== OpenGL performance ==
{{See also|Profiling performance}}

OpenGL performance can be tested using glmark2 program. It is available in most Linux distributions. In Debian derived distributions (like Ubuntu) it can be installed by issuing ''sudo apt install glmark2'' from command line.

The data presented below was taken by running ''glmark2'' without any additional options, i.e. with default settings, on an otherwise idle system.

By comparing your results with measurements taken on other similar systems you can verify if your hardware and software combination is performing as expected.

=== Integrated graphics ===
==== Intel i5-4310M @ 2.70 GHz (integrated Intel HD 4600 GPU) ====

'''glmark2 Score: 1668'''

{{collapsible script
| type = details
| title = (click show to expand)
| lang = text
| script = ----
glmark2 2014.03+git20150611.fa71af2d
----
OpenGL Information
GL_VENDOR: Intel Open Source Technology Center
GL_RENDERER: Mesa DRI Intel(R) Haswell Mobile
GL_VERSION: 3.0 Mesa 18.0.5
----
<pre>
[build] use-vbo=false: FPS: 2256 FrameTime: 0.443 ms
[build] use-vbo=true: FPS: 2500 FrameTime: 0.400 ms
[texture] texture-filter=nearest: FPS: 2183 FrameTime: 0.458 ms
[texture] texture-filter=linear: FPS: 2180 FrameTime: 0.459 ms
[texture] texture-filter=mipmap: FPS: 2250 FrameTime: 0.444 ms
[shading] shading=gouraud: FPS: 2042 FrameTime: 0.490 ms
[shading] shading=blinn-phong-inf: FPS: 2049 FrameTime: 0.488 ms
[shading] shading=phong: FPS: 1938 FrameTime: 0.516 ms
[shading] shading=cel: FPS: 2037 FrameTime: 0.491 ms
[bump] bump-render=high-poly: FPS: 1701 FrameTime: 0.588 ms
[bump] bump-render=normals: FPS: 2419 FrameTime: 0.413 ms
[bump] bump-render=height: FPS: 2382 FrameTime: 0.420 ms
[effect2d] kernel=0,1,0;1,-4,1;0,1,0;: FPS: 1758 FrameTime: 0.569 ms
[effect2d] kernel=1,1,1,1,1;1,1,1,1,1;1,1,1,1,1;: FPS: 886 FrameTime: 1.129 ms
[pulsar] light=false:quads=5:texture=false: FPS: 2008 FrameTime: 0.498 ms
[desktop] blur-radius=5:effect=blur:passes=1:separable=true:windows=4: FPS: 749 FrameTime: 1.335 ms
[desktop] effect=shadow:windows=4: FPS: 1094 FrameTime: 0.914 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 770 FrameTime: 1.299 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=subdata: FPS: 655 FrameTime: 1.527 ms
[buffer] columns=200:interleave=true:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 857 FrameTime: 1.167 ms
[ideas] speed=duration: FPS: 1776 FrameTime: 0.563 ms
[jellyfish] <default>: FPS: 1275 FrameTime: 0.784 ms
[terrain] <default>: FPS: 173 FrameTime: 5.780 ms
[shadow] <default>: FPS: 805 FrameTime: 1.242 ms
[refract] <default>: FPS: 268 FrameTime: 3.731 ms
[conditionals] fragment-steps=0:vertex-steps=0: FPS: 2038 FrameTime: 0.491 ms
[conditionals] fragment-steps=5:vertex-steps=0: FPS: 2039 FrameTime: 0.490 ms
[conditionals] fragment-steps=0:vertex-steps=5: FPS: 2028 FrameTime: 0.493 ms
[function] fragment-complexity=low:fragment-steps=5: FPS: 2037 FrameTime: 0.491 ms
[function] fragment-complexity=medium:fragment-steps=5: FPS: 2051 FrameTime: 0.488 ms
[loop] fragment-loop=false:fragment-steps=5:vertex-steps=5: FPS: 1879 FrameTime: 0.532 ms
[loop] fragment-steps=5:fragment-uniform=false:vertex-steps=5: FPS: 1922 FrameTime: 0.520 ms
[loop] fragment-steps=5:fragment-uniform=true:vertex-steps=5: FPS: 2039 FrameTime: 0.490 ms</pre>
}}

==== Intel i5-6200U @ 2.3 GHz (integrated Intel UHD 620 GPU) ====
Remark: CPU clock boosted to 2.8 GHz during benchmarking

'''glmark2 Score: 1294'''

{{collapsible script
| type = details
| title = (click show to expand)
| lang = text
| script = ----
glmark2 2021.02
----
OpenGL Information
GL_VENDOR: Intel
GL_RENDERER: Mesa Intel(R) HD Graphics 520 (SKL GT2)
GL_VERSION: 4.6 (Compatibility Profile) Mesa 21.0.3
----
[build] use-vbo=false: FPS: 1500 FrameTime: 0.667 ms
[build] use-vbo=true: FPS: 1959 FrameTime: 0.510 ms
[texture] texture-filter=nearest: FPS: 1722 FrameTime: 0.581 ms
[texture] texture-filter=linear: FPS: 1736 FrameTime: 0.576 ms
[texture] texture-filter=mipmap: FPS: 1673 FrameTime: 0.598 ms
[shading] shading=gouraud: FPS: 1584 FrameTime: 0.631 ms
[shading] shading=blinn-phong-inf: FPS: 1554 FrameTime: 0.644 ms
[shading] shading=phong: FPS: 1559 FrameTime: 0.641 ms
[shading] shading=cel: FPS: 1571 FrameTime: 0.637 ms
[bump] bump-render=high-poly: FPS: 1123 FrameTime: 0.890 ms
[bump] bump-render=normals: FPS: 1945 FrameTime: 0.514 ms
[bump] bump-render=height: FPS: 1881 FrameTime: 0.532 ms
[effect2d] kernel=0,1,0;1,-4,1;0,1,0;: FPS: 1359 FrameTime: 0.736 ms
[effect2d] kernel=1,1,1,1,1;1,1,1,1,1;1,1,1,1,1;: FPS: 851 FrameTime: 1.175 ms
[pulsar] light=false:quads=5:texture=false: FPS: 1646 FrameTime: 0.608 ms
[desktop] blur-radius=5:effect=blur:passes=1:separable=true:windows=4: FPS: 757 FrameTime: 1.321 ms
[desktop] effect=shadow:windows=4: FPS: 1094 FrameTime: 0.914 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 585 FrameTime: 1.709 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=subdata: FPS: 529 FrameTime: 1.890 ms
[buffer] columns=200:interleave=true:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 669 FrameTime: 1.495 ms
[ideas] speed=duration: FPS: 1489 FrameTime: 0.672 ms
[jellyfish] <default>: FPS: 1236 FrameTime: 0.809 ms
[terrain] <default>: FPS: 188 FrameTime: 5.319 ms
[shadow] <default>: FPS: 1014 FrameTime: 0.986 ms
[refract] <default>: FPS: 356 FrameTime: 2.809 ms
[conditionals] fragment-steps=0:vertex-steps=0: FPS: 1360 FrameTime: 0.735 ms
[conditionals] fragment-steps=5:vertex-steps=0: FPS: 1407 FrameTime: 0.711 ms
[conditionals] fragment-steps=0:vertex-steps=5: FPS: 1393 FrameTime: 0.718 ms
[function] fragment-complexity=low:fragment-steps=5: FPS: 1412 FrameTime: 0.708 ms
[function] fragment-complexity=medium:fragment-steps=5: FPS: 1416 FrameTime: 0.706 ms
[loop] fragment-loop=false:fragment-steps=5:vertex-steps=5: FPS: 1369 FrameTime: 0.730 ms
[loop] fragment-steps=5:fragment-uniform=false:vertex-steps=5: FPS: 1388 FrameTime: 0.720 ms
[loop] fragment-steps=5:fragment-uniform=true:vertex-steps=5: FPS: 1383 FrameTime: 0.723 ms
}}

=== Discrete graphics card ===
Note: this section also contains hybrid configurations (e.g. laptops with dual GPU technology)

==== AMD FirePro M5950 + Intel i5-2520M ====
Remark: dual GPU technology laptop, no test details available.

'''glmark2 Score: 5600'''

==== NVIDIA RTX2060 6GB + AMD Ryzen 7 3700X 8-Core 4GHz ====
Note: one tests resulted in errors and finally a core dump.
Another test on the same hardware, with different drivers, completed.
Both test details are included.

'''glmark2 Score: 9537'''

{{collapsible script
| type = details
| title = (click show to expand)
| lang = text
| script =----
glmark2 2021.02
----
OpenGL Information
GL_VENDOR: NVIDIA Corporation
GL_RENDERER: NVIDIA GeForce RTX 2060/PCIe/SSE2
GL_VERSION: 4.6.0 NVIDIA 495.46
----
<pre>
[build] use-vbo=false: FPS: 13809 FrameTime: 0.072 ms
[build] use-vbo=true: FPS: 28367 FrameTime: 0.035 ms
[texture] texture-filter=nearest: FPS: 27958 FrameTime: 0.036 ms
[texture] texture-filter=linear: FPS: 28120 FrameTime: 0.036 ms
[texture] texture-filter=mipmap: FPS: 28036 FrameTime: 0.036 ms
[shading] shading=gouraud: FPS: 26428 FrameTime: 0.038 ms
[shading] shading=blinn-phong-inf: FPS: 26320 FrameTime: 0.038 ms
[shading] shading=phong: FPS: 25800 FrameTime: 0.039 ms
[shading] shading=cel: FPS: 25498 FrameTime: 0.039 ms
[bump] bump-render=high-poly: FPS: 20696 FrameTime: 0.048 ms
[bump] bump-render=normals: FPS: 29599 FrameTime: 0.034 ms
Error: Failed to add fragment shader from file None:
Error: 0(15) : error C0000: syntax error, unexpected identifier, expecting "::" at token "highp"
Error: 0(36) : warning C1503: undefined variable "TextureCoord"
Error: 0(37) : warning C1503: undefined variable "TextureCoord"
Error: 0(38) : warning C1503: undefined variable "TextureCoord"
Error:
[bump] bump-render=height: Set up failed
[effect2d] kernel=0,1,0;1,-4,1;0,1,0;: FPS: 22140 FrameTime: 0.045 ms
[effect2d] kernel=1,1,1,1,1;1,1,1,1,1;1,1,1,1,1;: FPS: 15018 FrameTime: 0.067 ms
[pulsar] light=false:quads=5:texture=false: FPS: 27482 FrameTime: 0.036 ms
[desktop] blur-radius=5:effect=blur:passes=1:separable=true:windows=4: FPS: 8226 FrameTime: 0.122 ms
[desktop] effect=shadow:windows=4: FPS: 10260 FrameTime: 0.097 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 1490 FrameTime: 0.671 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=subdata: FPS: 1613 FrameTime: 0.620 ms
[buffer] columns=200:interleave=true:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 2147 FrameTime: 0.466 ms
[ideas] speed=duration: FPS: 14164 FrameTime: 0.071 ms
[jellyfish] <default>: FPS: 20591 FrameTime: 0.049 ms
Error: Failed to add fragment shader from file None:
Error: 0(26) : warning C7022: unrecognized profile specifier "highp"
Error: 0(26) : error C0502: syntax error at token "highp"
Error:
Error: Failed to add fragment shader from file None:
Error: 0(75) : warning C7022: unrecognized profile specifier "highp"
Error: 0(75) : error C0502: syntax error at token "highp"
Error:
[terrain] <default>:Segmentation fault (core dumped)</pre>
}}

{{collapsible script
| type = details
| title = (click show to expand)
| lang = text
| script =----
glmark2 2021.02
----
OpenGL Information
GL_VENDOR: NVIDIA Corporation
GL_RENDERER: NVIDIA GeForce RTX 2060/PCIe/SSE2
GL_VERSION: 4.6.0 NVIDIA 515.65.01
----
<pre>
[build] use-vbo=false: FPS: 8231 FrameTime: 0.121 ms
[build] use-vbo=true: FPS: 11817 FrameTime: 0.085 ms
[texture] texture-filter=nearest: FPS: 11830 FrameTime: 0.085 ms
[texture] texture-filter=linear: FPS: 11822 FrameTime: 0.085 ms
[texture] texture-filter=mipmap: FPS: 11813 FrameTime: 0.085 ms
[shading] shading=gouraud: FPS: 11501 FrameTime: 0.087 ms
[shading] shading=blinn-phong-inf: FPS: 11429 FrameTime: 0.087 ms
[shading] shading=phong: FPS: 11334 FrameTime: 0.088 ms
[shading] shading=cel: FPS: 11262 FrameTime: 0.089 ms
[bump] bump-render=high-poly: FPS: 10097 FrameTime: 0.099 ms
[bump] bump-render=normals: FPS: 12168 FrameTime: 0.082 ms
[bump] bump-render=height: FPS: 12004 FrameTime: 0.083 ms
[effect2d] kernel=0,1,0;1,-4,1;0,1,0;: FPS: 10522 FrameTime: 0.095 ms
[effect2d] kernel=1,1,1,1,1;1,1,1,1,1;1,1,1,1,1;: FPS: 8468 FrameTime: 0.118 ms
[pulsar] light=false:quads=5:texture=false: FPS: 11776 FrameTime: 0.085 ms
[desktop] blur-radius=5:effect=blur:passes=1:separable=true:windows=4: FPS: 5667 FrameTime: 0.176 ms
[desktop] effect=shadow:windows=4: FPS: 8895 FrameTime: 0.112 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 1796 FrameTime: 0.557 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=subdata: FPS: 2017 FrameTime: 0.496 ms
[buffer] columns=200:interleave=true:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 2176 FrameTime: 0.460 ms
[ideas] speed=duration: FPS: 10641 FrameTime: 0.094 ms
[jellyfish] <default>: FPS: 10085 FrameTime: 0.099 ms
[terrain] <default>: FPS: 1323 FrameTime: 0.756 ms
[shadow] <default>: FPS: 9418 FrameTime: 0.106 ms
[refract] <default>: FPS: 4595 FrameTime: 0.218 ms
[conditionals] fragment-steps=0:vertex-steps=0: FPS: 11552 FrameTime: 0.087 ms
[conditionals] fragment-steps=5:vertex-steps=0: FPS: 11498 FrameTime: 0.087 ms
[conditionals] fragment-steps=0:vertex-steps=5: FPS: 11555 FrameTime: 0.087 ms
[function] fragment-complexity=low:fragment-steps=5: FPS: 11586 FrameTime: 0.086 ms
[function] fragment-complexity=medium:fragment-steps=5: FPS: 11454 FrameTime: 0.087 ms
[loop] fragment-loop=false:fragment-steps=5:vertex-steps=5: FPS: 11521 FrameTime: 0.087 ms
[loop] fragment-steps=5:fragment-uniform=false:vertex-steps=5: FPS: 11495 FrameTime: 0.087 ms
[loop] fragment-steps=5:fragment-uniform=true:vertex-steps=5: FPS: 11403 FrameTime: 0.088 ms</pre>
}}

==== AMD Tahiti XT [Radeon HD 7970 / R9 280X] + Intel Core i5-11600K @ 3.90GHz ====

'''glmark2 Score: 13781'''

{{collapsible script
| type = details
| title = (click show to expand)
| lang = text
| script = ----
glmark2 2021.02
----
OpenGL Information
GL_VENDOR: AMD
GL_RENDERER: AMD TAHITI (DRM 2.50.0, 5.11.0-44-generic, LLVM 12.0.0)
GL_VERSION: 4.5 (Compatibility Profile) Mesa 21.0.3
----
[build] use-vbo=false: FPS: 12290 FrameTime: 0.081 ms
[build] use-vbo=true: FPS: 19086 FrameTime: 0.052 ms
[texture] texture-filter=nearest: FPS: 18131 FrameTime: 0.055 ms
[texture] texture-filter=linear: FPS: 18165 FrameTime: 0.055 ms
[texture] texture-filter=mipmap: FPS: 18563 FrameTime: 0.054 ms
[shading] shading=gouraud: FPS: 16185 FrameTime: 0.062 ms
[shading] shading=blinn-phong-inf: FPS: 16135 FrameTime: 0.062 ms
[shading] shading=phong: FPS: 16042 FrameTime: 0.062 ms
[shading] shading=cel: FPS: 16036 FrameTime: 0.062 ms
[bump] bump-render=high-poly: FPS: 9338 FrameTime: 0.107 ms
[bump] bump-render=normals: FPS: 19774 FrameTime: 0.051 ms
[bump] bump-render=height: FPS: 19534 FrameTime: 0.051 ms
[effect2d] kernel=0,1,0;1,-4,1;0,1,0;: FPS: 15477 FrameTime: 0.065 ms
[effect2d] kernel=1,1,1,1,1;1,1,1,1,1;1,1,1,1,1;: FPS: 10139 FrameTime: 0.099 ms
[pulsar] light=false:quads=5:texture=false: FPS: 16858 FrameTime: 0.059 ms
[desktop] blur-radius=5:effect=blur:passes=1:separable=true:windows=4: FPS: 5961 FrameTime: 0.168 ms
[desktop] effect=shadow:windows=4: FPS: 9994 FrameTime: 0.100 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 2577 FrameTime: 0.388 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=subdata: FPS: 3585 FrameTime: 0.279 ms
[buffer] columns=200:interleave=true:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 3158 FrameTime: 0.317 ms
[ideas] speed=duration: FPS: 11924 FrameTime: 0.084 ms
[jellyfish] <default>: FPS: 12073 FrameTime: 0.083 ms
[terrain] <default>: FPS: 1350 FrameTime: 0.741 ms
[shadow] <default>: FPS: 9986 FrameTime: 0.100 ms
[refract] <default>: FPS: 2500 FrameTime: 0.400 ms
[conditionals] fragment-steps=0:vertex-steps=0: FPS: 18815 FrameTime: 0.053 ms
[conditionals] fragment-steps=5:vertex-steps=0: FPS: 18705 FrameTime: 0.053 ms
[conditionals] fragment-steps=0:vertex-steps=5: FPS: 18787 FrameTime: 0.053 ms
[function] fragment-complexity=low:fragment-steps=5: FPS: 18759 FrameTime: 0.053 ms
[function] fragment-complexity=medium:fragment-steps=5: FPS: 18691 FrameTime: 0.054 ms
[loop] fragment-loop=false:fragment-steps=5:vertex-steps=5: FPS: 18755 FrameTime: 0.053 ms
[loop] fragment-steps=5:fragment-uniform=false:vertex-steps=5: FPS: 18759 FrameTime: 0.053 ms
[loop] fragment-steps=5:fragment-uniform=true:vertex-steps=5: FPS: 18654 FrameTime: 0.054 ms
}}

==== NVIDIA GTX 1060 6GB + Intel Core i5-11600K @ 3.90GHz, driver ver. 535.129.03 ====

'''glmark2 Score: 11817'''

{{collapsible script
| type = details
| title = (click show to expand)
| lang = text
| script = ----
glmark2 2021.02
----
OpenGL Information
GL_VENDOR: NVIDIA Corporation
GL_RENDERER: NVIDIA GeForce GTX 1060 6GB/PCIe/SSE2
GL_VERSION: 4.6.0 NVIDIA 535.129.03
----
[build] use-vbo=false: FPS: 9928 FrameTime: 0.101 ms
[build] use-vbo=true: FPS: 15678 FrameTime: 0.064 ms
[texture] texture-filter=nearest: FPS: 14755 FrameTime: 0.068 ms
[texture] texture-filter=linear: FPS: 14812 FrameTime: 0.068 ms
[texture] texture-filter=mipmap: FPS: 14878 FrameTime: 0.067 ms
[shading] shading=gouraud: FPS: 14048 FrameTime: 0.071 ms
[shading] shading=blinn-phong-inf: FPS: 14006 FrameTime: 0.071 ms
[shading] shading=phong: FPS: 13706 FrameTime: 0.073 ms
[shading] shading=cel: FPS: 13818 FrameTime: 0.072 ms
[bump] bump-render=high-poly: FPS: 11147 FrameTime: 0.090 ms
[bump] bump-render=normals: FPS: 15848 FrameTime: 0.063 ms
[bump] bump-render=height: FPS: 15815 FrameTime: 0.063 ms
[effect2d] kernel=0,1,0;1,-4,1;0,1,0;: FPS: 12968 FrameTime: 0.077 ms
[effect2d] kernel=1,1,1,1,1;1,1,1,1,1;1,1,1,1,1;: FPS: 9205 FrameTime: 0.109 ms
[pulsar] light=false:quads=5:texture=false: FPS: 15094 FrameTime: 0.066 ms
[desktop] blur-radius=5:effect=blur:passes=1:separable=true:windows=4: FPS: 5891 FrameTime: 0.170 ms
[desktop] effect=shadow:windows=4: FPS: 9839 FrameTime: 0.102 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 2797 FrameTime: 0.358 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=subdata: FPS: 3745 FrameTime: 0.267 ms
[buffer] columns=200:interleave=true:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 3421 FrameTime: 0.292 ms
[ideas] speed=duration: FPS: 12804 FrameTime: 0.078 ms
[jellyfish] <default>: FPS: 11401 FrameTime: 0.088 ms
[terrain] <default>: FPS: 1413 FrameTime: 0.708 ms
[shadow] <default>: FPS: 10602 FrameTime: 0.094 ms
[refract] <default>: FPS: 4095 FrameTime: 0.244 ms
[conditionals] fragment-steps=0:vertex-steps=0: FPS: 15145 FrameTime: 0.066 ms
[conditionals] fragment-steps=5:vertex-steps=0: FPS: 14786 FrameTime: 0.068 ms
[conditionals] fragment-steps=0:vertex-steps=5: FPS: 15005 FrameTime: 0.067 ms
[function] fragment-complexity=low:fragment-steps=5: FPS: 14627 FrameTime: 0.068 ms
[function] fragment-complexity=medium:fragment-steps=5: FPS: 14700 FrameTime: 0.068 ms
[loop] fragment-loop=false:fragment-steps=5:vertex-steps=5: FPS: 14645 FrameTime: 0.068 ms
[loop] fragment-steps=5:fragment-uniform=false:vertex-steps=5: FPS: 14682 FrameTime: 0.068 ms
[loop] fragment-steps=5:fragment-uniform=true:vertex-steps=5: FPS: 14675 FrameTime: 0.068 ms
}}

==== NVIDIA GTX-1060 6GB + AMD R7 3700X @ 4.2 GHz, 8 cores, HT off, driver ver. 460.91.03 ====

'''glmark2 Score: 20641'''

{{collapsible script
| type = details
| title = (click show to expand)
| lang = text
| script = ----
glmark2 2014.03+git20150611.fa71af2d
----
OpenGL Information
GL_VENDOR: NVIDIA Corporation
GL_RENDERER: GeForce GTX 1060 6GB/PCIe/SSE2
GL_VERSION: 4.6.0 NVIDIA 460.91.03
----
[build] use-vbo=false: FPS: 15192 FrameTime: 0.066 ms
[build] use-vbo=true: FPS: 30325 FrameTime: 0.033 ms
[texture] texture-filter=nearest: FPS: 27634 FrameTime: 0.036 ms
[texture] texture-filter=linear: FPS: 27511 FrameTime: 0.036 ms
[texture] texture-filter=mipmap: FPS: 28397 FrameTime: 0.035 ms
[shading] shading=gouraud: FPS: 26079 FrameTime: 0.038 ms
[shading] shading=blinn-phong-inf: FPS: 25796 FrameTime: 0.039 ms
[shading] shading=phong: FPS: 25060 FrameTime: 0.040 ms
[shading] shading=cel: FPS: 25321 FrameTime: 0.039 ms
[bump] bump-render=high-poly: FPS: 17451 FrameTime: 0.057 ms
[bump] bump-render=normals: FPS: 31963 FrameTime: 0.031 ms
[bump] bump-render=height: FPS: 31608 FrameTime: 0.032 ms
[effect2d] kernel=0,1,0;1,-4,1;0,1,0;: FPS: 20418 FrameTime: 0.049 ms
[effect2d] kernel=1,1,1,1,1;1,1,1,1,1;1,1,1,1,1;: FPS: 12585 FrameTime: 0.079 ms
[pulsar] light=false:quads=5:texture=false: FPS: 28174 FrameTime: 0.035 ms
[desktop] blur-radius=5:effect=blur:passes=1:separable=true:windows=4: FPS: 7331 FrameTime: 0.136 ms
[desktop] effect=shadow:windows=4: FPS: 14034 FrameTime: 0.071 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 2363 FrameTime: 0.423 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=subdata: FPS: 2783 FrameTime: 0.359 ms
[buffer] columns=200:interleave=true:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 2330 FrameTime: 0.429 ms
[ideas] speed=duration: FPS: 19421 FrameTime: 0.051 ms
[jellyfish] <default>: FPS: 17291 FrameTime: 0.058 ms
[terrain] <default>: FPS: 1349 FrameTime: 0.741 ms
[shadow] <default>: FPS: 15688 FrameTime: 0.064 ms
[refract] <default>: FPS: 4783 FrameTime: 0.209 ms
[conditionals] fragment-steps=0:vertex-steps=0: FPS: 28599 FrameTime: 0.035 ms
[conditionals] fragment-steps=5:vertex-steps=0: FPS: 27499 FrameTime: 0.036 ms
[conditionals] fragment-steps=0:vertex-steps=5: FPS: 28191 FrameTime: 0.035 ms
[function] fragment-complexity=low:fragment-steps=5: FPS: 27695 FrameTime: 0.036 ms
[function] fragment-complexity=medium:fragment-steps=5: FPS: 26605 FrameTime: 0.038 ms
[loop] fragment-loop=false:fragment-steps=5:vertex-steps=5: FPS: 27340 FrameTime: 0.037 ms
[loop] fragment-steps=5:fragment-uniform=false:vertex-steps=5: FPS: 27361 FrameTime: 0.037 ms
[loop] fragment-steps=5:fragment-uniform=true:vertex-steps=5: FPS: 26984 FrameTime: 0.037 ms
}}

==== NVIDIA Quadro K1000M 1GB + Intel Core i7-3610Q @ 2.3 GHz ====
Remark: during glmark2 testing CPU clock boosted to 3.3 GHz

''' glmark2 Score: 2754 '''

{{collapsible script
| type = details
| title = (click show to expand)
| lang = text
| script = ----
glmark2 2014.03+git20150611.fa71af2d
----
OpenGL Information
GL_VENDOR: NVIDIA Corporation
GL_RENDERER: Quadro K1000M/PCIe/SSE2
GL_VERSION: 4.6.0 NVIDIA 390.138
----
[build] use-vbo=false: FPS: 4154 FrameTime: 0.241 ms
[build] use-vbo=true: FPS: 4205 FrameTime: 0.238 ms
[texture] texture-filter=nearest: FPS: 3791 FrameTime: 0.264 ms
[texture] texture-filter=linear: FPS: 3718 FrameTime: 0.269 ms
[texture] texture-filter=mipmap: FPS: 3761 FrameTime: 0.266 ms
[shading] shading=gouraud: FPS: 3187 FrameTime: 0.314 ms
[shading] shading=blinn-phong-inf: FPS: 3200 FrameTime: 0.312 ms
[shading] shading=phong: FPS: 3078 FrameTime: 0.325 ms
[shading] shading=cel: FPS: 3065 FrameTime: 0.326 ms
[bump] bump-render=high-poly: FPS: 1674 FrameTime: 0.597 ms
[bump] bump-render=normals: FPS: 4329 FrameTime: 0.231 ms
[bump] bump-render=height: FPS: 4174 FrameTime: 0.240 ms
[effect2d] kernel=0,1,0;1,-4,1;0,1,0;: FPS: 2356 FrameTime: 0.424 ms
[effect2d] kernel=1,1,1,1,1;1,1,1,1,1;1,1,1,1,1;: FPS: 1249 FrameTime: 0.801 ms
[pulsar] light=false:quads=5:texture=false: FPS: 3550 FrameTime: 0.282 ms
[desktop] blur-radius=5:effect=blur:passes=1:separable=true:windows=4: FPS: 888 FrameTime: 1.126 ms
[desktop] effect=shadow:windows=4: FPS: 1453 FrameTime: 0.688 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 952 FrameTime: 1.050 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=subdata: FPS: 1277 FrameTime: 0.783 ms
[buffer] columns=200:interleave=true:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 977 FrameTime: 1.024 ms
[ideas] speed=duration: FPS: 2926 FrameTime: 0.342 ms
[jellyfish] <default>: FPS: 1551 FrameTime: 0.645 ms
[terrain] <default>: FPS: 173 FrameTime: 5.780 ms
[shadow] <default>: FPS: 2420 FrameTime: 0.413 ms
[refract] <default>: FPS: 431 FrameTime: 2.320 ms
[conditionals] fragment-steps=0:vertex-steps=0: FPS: 3776 FrameTime: 0.265 ms
[conditionals] fragment-steps=5:vertex-steps=0: FPS: 3061 FrameTime: 0.327 ms
[conditionals] fragment-steps=0:vertex-steps=5: FPS: 3776 FrameTime: 0.265 ms
[function] fragment-complexity=low:fragment-steps=5: FPS: 3775 FrameTime: 0.265 ms
[function] fragment-complexity=medium:fragment-steps=5: FPS: 3058 FrameTime: 0.327 ms
[loop] fragment-loop=false:fragment-steps=5:vertex-steps=5: FPS: 3776 FrameTime: 0.265 ms
[loop] fragment-steps=5:fragment-uniform=false:vertex-steps=5: FPS: 3776 FrameTime: 0.265 ms
[loop] fragment-steps=5:fragment-uniform=true:vertex-steps=5: FPS: 3375 FrameTime: 0.296 ms
}}

==== NVIDIA GTX 750 + Intel Core i5-2550K @ 3.4 GHz ====
Remark: no test details available.

'''glmark2 Score: 9000'''

==== NVIDIA GTX 1060 + Intel Core i5-2550K @ 3.4 GHz ====
Remark: no test details available.

'''glmark2 Score: 19000'''

Howto:Add procedures to the route manager

2023-11-08T18:27:16Z

MariuszXC:

{{Stub}}
{{Autoflight Navigation}}

== Objective ==
A free way to get more SID and STAR procedures for the FlightGear Route Planner<ref>{{cite web
|url = https://forum.flightgear.org/viewtopic.php?p=313123#p313123
|title = <nowiki> routeplanner stir sid </nowiki>
|author = <nowiki> Sarith </nowiki>
|date = Jun 24th, 2017
|added = Jun 24th, 2017
|script_version = 0.40
}}</ref>

== Background ==
Make some yourself. Charts are easy to find and a quick search will find you the syntax.
This is what FlightGear is all about; doing it yourself and sharing it to others.
A quick search would also find existing packages...<ref>{{cite web
|url = https://forum.flightgear.org/viewtopic.php?p=313128#p313128
|title = <nowiki> Re: routeplanner stir sid </nowiki>
|author = <nowiki> Parnikkapore </nowiki>
|date = Jun 24th, 2017
|added = Jun 24th, 2017
|script_version = 0.40
}}</ref>

== Instructions ==
SID and STAR procedures are found in the airport's procedures.xml file. There is at most one file per airport and it is located in the airport's root directory:

<scenery directory>/Airports/I/C/A/ICAO.procedures.xml

Where ICAO is your airport code.<ref>{{cite web
|url = https://forum.flightgear.org/viewtopic.php?p=313362#p313362
|title = <nowiki> Re: routeplanner stir sid </nowiki>
|author = <nowiki> Parnikkapore </nowiki>
|date = Jun 28th, 2017
|added = Jun 28th, 2017
|script_version = 0.40
}}</ref>

For example, to import SID or STAR procedures for VTSP (Phuket International Airport), you name the file VTSP.procedures.xml and put it in the <scenery directory>/Airports/V/T/S/ directory. In there you will likely find VTSP.twr.xml but not an existing VTSP.procedures.xml file.
Replace "VTSP" in the directory and procedures.xml file name with your airport code.<ref>{{cite web
|url = https://forum.flightgear.org/viewtopic.php?p=313409#p313409
|title = <nowiki> Re: routeplanner stir sid </nowiki>
|author = <nowiki> Parnikkapore </nowiki>
|date = Jun 29th, 2017
|added = Jun 29th, 2017
|script_version = 0.40
}}</ref>

== File Structure ==

In the explanation below, the name like "ProceduresDB" is the tag - so it's actually <ProceduresDB> in the XML file.
The subsequent parameters, like "build" are attributes - so it's actually <ProceduresDB build=""> in the XML file.

<pre>
ProceduresDB [build] (one of these per file)
|
Airport [ICAOcode] (one of these per file)
|
Sid [Name, Runways (comma separated - example: "08L,08R")] (many of these per Airport)
|
Sid_Waypoint [ID (unique sequential integer)] (many of these per Sid)
|
Name
Type
Latitude
Longitude
Speed
Altitude
AltitudeCons
AltitudeRestriction (one of "above" or "below" or "at")
Hdg_Crs (optional. example value = "1")
Hdg_Crs_Value (optional. heading degrees)
Sp_Turn (optional. example value = "Auto")
...
Sid_Transition [Name] (just one of these per Sid)
|
SidTr_Waypoint [ID] (many of these per Sid_Transition)

Star [Name] (many of these per Airport)
|
Star_Waypoint [ID] (many of these per Star)
...
Star_Transition [Name] (just one of these per Star)
|
StarTr_Waypoint [ID] (many of these per Star_Transition)

Approach [Name] (e.g., ILS08L - uses IL, if appropriate, and the runway name by convention)
|
App_Waypoint [ID]
App_Transition [Name] (just one of these per Approach)
|
AppTr_Waypoint [ID] (many of these per App_Transition)
</pre>

== Sample procedures.xml File ==

Here is a link to an example xml file which follows the format specified above: https://github.com/jojo2357/flightgear-star-sid-manager/blob/master/2020.4/Airports/K/A/T/KATL.procedures.xml<ref>{{cite web
|url = https://forum.flightgear.org/viewtopic.php?p=313583#p313583
|title = <nowiki> Re: routeplanner stir sid </nowiki>
|author = <nowiki> eric </nowiki>
|date = Jul 2nd, 2017
|added = Jul 2nd, 2017
|script_version = 0.40
}}</ref>
== Bash script ==
ZirconiumX wrote a bash script for putting the XML files into the FG required locations.<ref>{{cite web
|url = https://forum.flightgear.org/viewtopic.php?p=280561#p280561
|title = <nowiki> Re: Non-Navigraph SID/STAR xml files </nowiki>
|author = <nowiki> ZirconiumX </nowiki>
|date = Mar 26th, 2016
|added = Mar 26th, 2016
|script_version = 0.40
}}</ref>

<syntaxhighlight lang="bash">
for file in $(ls *.xml)
do
# First, rename all the files to the correct convention
mv "$file" "${file%.xml}.procedures.xml"

# Then move it to the correct place
icao=${file%.xml}
icao1=$(echo $icao | cut -c 1)
icao2=$(echo $icao | cut -c 2)
icao3=$(echo $icao | cut -c 3)
mkdir -p $icao1/$icao2/$icao3
mv "${icao}.procedures.xml" "$icao1/$icao2/$icao3/${icao}.procedures.xml"
done
</syntaxhighlight>

== Installing free community procedures ==
The FAA provides the [https://www.faa.gov/air_traffic/flight_info/aeronav/digital_products/cifp/ CIFP] which provides procedure data for airports under the purview of the FAA, namely the US.

There is a free project on [https://github.com/jojo2357/flightgear-star-sid-manager GitHub] that aims to take FAA data and format it into the LevelD required by FlightGear. For instructions on how to install, see [https://github.com/jojo2357/flightgear-star-sid-manager#installation this section] of the README.

This project uses GitHub Actions in order to automatically update the procedures at the start of a new AIRAC cycle.

== Commercial sources==
A process to import SID/STARs from Navigraph Level D (obtaining this data requires paid subscription to Navigraph) was described on the forum.

Quoting here for reference:{{cite web
|url=https://forum.flightgear.org/viewtopic.php?f=11&t=37975&start=15#p416078
|title = <nowiki> Re: How to get SIDs and STARs in Airbus A320 mcdu </nowiki>
|author = <nowiki> mpotra </nowiki>
|quote = :
# Download Level-D navdata from Navigraph (On the Downloads -> Manual Download page)
# This is ZIP file with a Windows Installer executable inside. If you're on Windows already, run the installer, select a version (Prepar3D/PD3) and then skip to step 4.
# The executable is a Inno Setup executable. In Linux you can extract the contents with `innoextractor -e leveld_2311.exe` for example, which will output a "code$AppName" directory.
# In the extracted directory you'll find a "navdata" folder containing XML files with procedures for all airports for the AIRAC cycle with filenames as "<ICAO>.xml".
# You can either rename in bulk or single file from "<ICAO>.xml" to "<ICAO>.procedures.xml" for desired airports.
# Create a new directory somewhere (anywhere you want) say "AIRAC/2311", and inside it create the "Airports" directory. (camel-case formatted - "airports" with small letter A didn't work for me)
# Inside this "Airports" directory, create new subdirectories for each airport you want to bring in, using the [I]/[C]/[A] format. For example, if you want to add Vienna airport LOWW, create the subdirectories "Airports/L/O/W" - do not create the fourth subdirectory [W] (it won't work)
# Copy the renamed file from step 5 into this last subdirectory. For example, copy "LOWW.procedures.xml" into "AIRAC/2311/Airports/L/O/W" directory, resulting in "AIRAC/2311/Airports/L/O/W/LOWW.procedures.xml". Example 2: for Budapest airport copy "LHBP.procedures.xml" into "AIRAC/2311/Airports/L/H/B", resulting in "AIRAC/2311/Airports/L/H/B/LHBP.procedures.xml"
# In FlightGear, add the "AIRAC/2311" directory to your sceneries paths.
# Reload FlightGear and enjoy SID/STARs in your MCDU
}}

==References==
{{Appendix}}

==Related content==
===Wiki articles===
*[[Route manager]]
*[[Flightplan XML formats]]

===Source code===
*{{flightgear source|path=src/Navaids/LevelDXML.hxx}}
*{{flightgear source|path=src/Navaids/LevelDXML.cxx}}

Howto:Add procedures to the route manager

2023-11-08T18:06:48Z

MariuszXC: Added description of Navigraph data extraction, from this post: https://forum.flightgear.org/viewtopic.php?f=11&t=37975&view=unread#p416078

{{Stub}}
{{Autoflight Navigation}}

== Objective ==
A free way to get more SID and STAR procedures for the FlightGear Route Planner<ref>{{cite web
|url = https://forum.flightgear.org/viewtopic.php?p=313123#p313123
|title = <nowiki> routeplanner stir sid </nowiki>
|author = <nowiki> Sarith </nowiki>
|date = Jun 24th, 2017
|added = Jun 24th, 2017
|script_version = 0.40
}}</ref>

== Background ==
Make some yourself. Charts are easy to find and a quick search will find you the syntax.
This is what FlightGear is all about; doing it yourself and sharing it to others.
A quick search would also find existing packages...<ref>{{cite web
|url = https://forum.flightgear.org/viewtopic.php?p=313128#p313128
|title = <nowiki> Re: routeplanner stir sid </nowiki>
|author = <nowiki> Parnikkapore </nowiki>
|date = Jun 24th, 2017
|added = Jun 24th, 2017
|script_version = 0.40
}}</ref>

== Instructions ==
SID and STAR procedures are found in the airport's procedures.xml file. There is at most one file per airport and it is located in the airport's root directory:

<scenery directory>/Airports/I/C/A/ICAO.procedures.xml

Where ICAO is your airport code.<ref>{{cite web
|url = https://forum.flightgear.org/viewtopic.php?p=313362#p313362
|title = <nowiki> Re: routeplanner stir sid </nowiki>
|author = <nowiki> Parnikkapore </nowiki>
|date = Jun 28th, 2017
|added = Jun 28th, 2017
|script_version = 0.40
}}</ref>

For example, to import SID or STAR procedures for VTSP (Phuket International Airport), you name the file VTSP.procedures.xml and put it in the <scenery directory>/Airports/V/T/S/ directory. In there you will likely find VTSP.twr.xml but not an existing VTSP.procedures.xml file.
Replace "VTSP" in the directory and procedures.xml file name with your airport code.<ref>{{cite web
|url = https://forum.flightgear.org/viewtopic.php?p=313409#p313409
|title = <nowiki> Re: routeplanner stir sid </nowiki>
|author = <nowiki> Parnikkapore </nowiki>
|date = Jun 29th, 2017
|added = Jun 29th, 2017
|script_version = 0.40
}}</ref>

== File Structure ==

In the explanation below, the name like "ProceduresDB" is the tag - so it's actually <ProceduresDB> in the XML file.
The subsequent parameters, like "build" are attributes - so it's actually <ProceduresDB build=""> in the XML file.

<pre>
ProceduresDB [build] (one of these per file)
|
Airport [ICAOcode] (one of these per file)
|
Sid [Name, Runways (comma separated - example: "08L,08R")] (many of these per Airport)
|
Sid_Waypoint [ID (unique sequential integer)] (many of these per Sid)
|
Name
Type
Latitude
Longitude
Speed
Altitude
AltitudeCons
AltitudeRestriction (one of "above" or "below" or "at")
Hdg_Crs (optional. example value = "1")
Hdg_Crs_Value (optional. heading degrees)
Sp_Turn (optional. example value = "Auto")
...
Sid_Transition [Name] (just one of these per Sid)
|
SidTr_Waypoint [ID] (many of these per Sid_Transition)

Star [Name] (many of these per Airport)
|
Star_Waypoint [ID] (many of these per Star)
...
Star_Transition [Name] (just one of these per Star)
|
StarTr_Waypoint [ID] (many of these per Star_Transition)

Approach [Name] (e.g., ILS08L - uses IL, if appropriate, and the runway name by convention)
|
App_Waypoint [ID]
App_Transition [Name] (just one of these per Approach)
|
AppTr_Waypoint [ID] (many of these per App_Transition)
</pre>

== Sample procedures.xml File ==

Here is a link to an example xml file which follows the format specified above: https://github.com/jojo2357/flightgear-star-sid-manager/blob/master/2020.4/Airports/K/A/T/KATL.procedures.xml<ref>{{cite web
|url = https://forum.flightgear.org/viewtopic.php?p=313583#p313583
|title = <nowiki> Re: routeplanner stir sid </nowiki>
|author = <nowiki> eric </nowiki>
|date = Jul 2nd, 2017
|added = Jul 2nd, 2017
|script_version = 0.40
}}</ref>
== Bash script ==
ZirconiumX wrote a bash script for putting the XML files into the FG required locations.<ref>{{cite web
|url = https://forum.flightgear.org/viewtopic.php?p=280561#p280561
|title = <nowiki> Re: Non-Navigraph SID/STAR xml files </nowiki>
|author = <nowiki> ZirconiumX </nowiki>
|date = Mar 26th, 2016
|added = Mar 26th, 2016
|script_version = 0.40
}}</ref>

<syntaxhighlight lang="bash">
for file in $(ls *.xml)
do
# First, rename all the files to the correct convention
mv "$file" "${file%.xml}.procedures.xml"

# Then move it to the correct place
icao=${file%.xml}
icao1=$(echo $icao | cut -c 1)
icao2=$(echo $icao | cut -c 2)
icao3=$(echo $icao | cut -c 3)
mkdir -p $icao1/$icao2/$icao3
mv "${icao}.procedures.xml" "$icao1/$icao2/$icao3/${icao}.procedures.xml"
done
</syntaxhighlight>

== Installing free community procedures ==
The FAA provides the [https://www.faa.gov/air_traffic/flight_info/aeronav/digital_products/cifp/ CIFP] which provides procedure data for airports under the purview of the FAA, namely the US.

There is a free project on [https://github.com/jojo2357/flightgear-star-sid-manager GitHub] that aims to take FAA data and format it into the LevelD required by FlightGear. For instructions on how to install, see [https://github.com/jojo2357/flightgear-star-sid-manager#installation this section] of the README.

This project uses GitHub Actions in order to automatically update the procedures at the start of a new AIRAC cycle.

== Commercial sources==
A process to import SID/STARs from Navigraph Level D (obtaining this data requires paid subscription to Navigraph) was described in this forum post: https://forum.flightgear.org/viewtopic.php?f=11&t=37975&start=15#p416078

Quoting here for reference:

# Download Level-D navdata from Navigraph (On the Downloads -> Manual Download page)
# This is ZIP file with a Windows Installer executable inside. If you're on Windows already, run the installer, select a version (Prepar3D/PD3) and then skip to step 4.
# The executable is a Inno Setup executable. In Linux you can extract the contents with `innoextractor -e leveld_2311.exe` for example, which will output a "code$AppName" directory.
# In the extracted directory you'll find a "navdata" folder containing XML files with procedures for all airports for the AIRAC cycle with filenames as "<ICAO>.xml".
# You can either rename in bulk or single file from "<ICAO>.xml" to "<ICAO>.procedures.xml" for desired airports.
# Create a new directory somewhere (anywhere you want) say "AIRAC/2311", and inside it create the "Airports" directory. (camel-case formatted - "airports" with small letter A didn't work for me)
# Inside this "Airports" directory, create new subdirectories for each airport you want to bring in, using the [I]/[C]/[A] format. For example, if you want to add Vienna airport LOWW, create the subdirectories "Airports/L/O/W" - do not create the fourth subdirectory [W] (it won't work)
# Copy the renamed file from step 5 into this last subdirectory. For example, copy "LOWW.procedures.xml" into "AIRAC/2311/Airports/L/O/W" directory, resulting in "AIRAC/2311/Airports/L/O/W/LOWW.procedures.xml". Example 2: for Budapest airport copy "LHBP.procedures.xml" into "AIRAC/2311/Airports/L/H/B", resulting in "AIRAC/2311/Airports/L/H/B/LHBP.procedures.xml"
# In FlightGear, add the "AIRAC/2311" directory to your sceneries paths.
# Reload FlightGear and enjoy SID/STARs in your MCDU

==References==
{{Appendix}}

==Related content==
===Wiki articles===
*[[Route manager]]
*[[Flightplan XML formats]]

===Source code===
*{{flightgear source|path=src/Navaids/LevelDXML.hxx}}
*{{flightgear source|path=src/Navaids/LevelDXML.cxx}}

Hackaton 2023 Proposal:Revive Atlas

2023-11-05T17:49:08Z

MariuszXC: Updated status of proposal

{| class="wikitable"

|-

|Title||'''<big>Revive Atlas</big>'''

|-

|Sponsor||MariuszXC

|-

|Supporters||

|-

|Status||Idea (work based on old code base was discarded).

|-

|Summary||This Forum thread https://forum.flightgear.org/viewtopic.php?f=25&t=41780 mentions the root of the problem.

|-

|Background||External free map tile servers may be disappearing or going pay-for-access anytime. Atlas is an old FG subproject, providing map tile generation (.png, .jpg) using FG scenery as input. It needs updating, because scenery evolved.

|-

|Details||

|-

|Skills||C++, GL, possibly some concurrent programming.

|-

|Notes||Roadmap:
a. get tile generation correct (while doing that, look into possible multithreading of generating different tiles),

b. make tiles available to Phi,

c. make tiles available to glass cockpits,

Remarks:

1. (a) could be done as a periodic batch process or by FG on demand, in a background task.

2. tiles for the same area may differ if user has custom scenery installed, therefore a local tile cache would have to be associated with the scenery.

Perhaps 'Atlas' subdirectory in every scenery tree?

3. (b) and (c) could be:

* either local file server (uses user's computer and disk, is always up to date with any scenery they are using),

* or a network tile server (incurs infrastructure cost, possibly feasible only for standard scenery),

* or both.

|}

[[Category:Hackathon 2023 Ideas]]

Hackaton 2023 Proposal:Additional signals

2023-11-05T15:39:30Z

MariuszXC: Created page with "{{Hackathon Proposal 2023 | title = Additional signals | sponsor = MariuszXC | supporters = | summary = Improving ground-referenced..."

{| class="wikitable"

|-

|Title||'''<big>Additional signals</big>'''

|-

|Sponsor||MariuszXC

|-

|Supporters||

|-

|Status||idea

|-

|Summary||Introducing additional signals during FG startup sequence.

|-

|Background||On slower hardware the initial scene rendering may be well incomplete, while the user is already given synthetic ATC messages (This is 'some airport', cleared for takeoff RWY...). This is too early given the yet unfinished scene rendering (actually a splash screen may still be present for a while).

|-

|Details||Currently there is the 'fdm-initialised' signal, which is used in many models as input to listeners. FG might benefit from extending the idea and generating similar notifications in other places of startup sequence. Such signals could then be used to trigger services (like mentioned ATC) in a proper manner.

|-

|Skills||C++, knowledge of FG core and core/Nasal interface.

|-

|Notes||Roadmap:

# identify critical events which should generate notifications (transition from splash to rendered scene looks like one such place)
# what to do when sim restarts?
# implementation and testing.

|}

[[Category:Hackathon 2023 Ideas]]

Hackaton 2023 Proposal:Road traffic realism

2023-11-05T15:08:29Z

MariuszXC: Created page with "{{Hackathon Proposal 2021 | title = Multiplayer Improvements | sponsor = MariuszXC | supporters = MariuszXC | summary = Improving ground-referenced..."

{| class="wikitable"

|-

|Title||'''<big>Road Traffic Realism</big>'''

|-

|Sponsor||MariuszXC

|-

|Supporters||

|-

|Status||Idea

|-

|Summary||Both RH (right hand) and LH (left hand) traffic rules are in force worldwide (plus chaotic driving in some areas, but we can skip that). Currently traffic shader implements only RH traffic.

|-

|Background||It is really quite disturbing to fly VFR near London and see RH traffic down below.

|-

|Details||

|-

|Skills||Shaders

|-

|Notes||Idea may look easy, but may require adding a LH/RH property to terrain and feeding that info to the traffic shader.

|}

[[Category:Hackathon 2023 Ideas]]

Hackaton 2023 Proposal:Improve MP realism at night

2023-11-05T15:01:28Z

MariuszXC: Created page with "{{Hackathon Proposal 2021 | title = Multiplayer Improvements | sponsor = MariuszXC | supporters = MariuszXC | summary = Improving ground-referenced..."

{| class="wikitable"

|-

|Title||'''MP Realism at Night'''

|-

|Sponsor||MariuszXC

|-

|Supporters||

|-

|Status||Work not yet started. Some ideas below.

|-

|Summary||At night models can disappear from view fast (as they should), but their navlights should remain visible at much greater distances (atmospheric conditions related).

|-

|Background||Model past LOD range will be removed from view completely, including lights. This is OK-ish at daytime, but spoils the realism at night, where lights are often the only means to spot other traffic. Perhaps a yet one more LOD (automatic, weather dependant?) setting is needed for lights objects?

|-

|Details||

|-

|Skills||C++, OSG, maybe XML if model-side modifications are deemed necessary.

|-

|Notes||Some lights are animated in a unique pattern (e.g. strobe lights). All lights may be switched on or off, this should follow the logic implemented model-side..

So a solution which keeps the remote (AI) model logic running, but hides most of the model from view (everything except lights?) might do the trick.

Remarks:

1. what about directional visiblity / view obscuring if rest of a model is idden? Maybe some 'bare bones' model is necessary?

2. identification of model parts (i.e. lights) to keep showing.

3. weather conditions integration - visibility range changing with weather.

|}

[[Category:Hackathon 2023 Ideas]]

Hackaton 2023 Proposal:Revive Atlas

2023-11-05T14:43:01Z

MariuszXC: Created page with "{{Hackathon Proposal 2021 | title = Multiplayer Improvements | sponsor = MariuszXC | supporters = MariuszXC | summary = Improving ground-referenced..."

{| class="wikitable"

|-

|Title||'''<big>Revive Atlas</big>'''

|-

|Sponsor||MariuszXC

|-

|Supporters||

|-

|Status||Work already started, repo (temporary) created on GitHub

|-

|Summary||This Forum thread https://forum.flightgear.org/viewtopic.php?f=25&t=41780 mentions the root of the problem and contains links to work already done, as well as some description of present issues.

|-

|Background||External free map tile servers may be disappearing or going pay-for-access anytime. Atlas is an old FG subproject, providing map tile generation (.png, .jpg) using FG scenery as input. It needs updating, because scenery evolved.

|-

|Details||

|-

|Skills||C++, GL, possibly some concurrent programming.

|-

|Notes||Roadmap:
a. get tile generation correct (while doing that, look into possible multithreading of generating different tiles),

b. make tiles available to Phi,

c. make tiles available to glass cockpits,

d. consider different scale/LOD for zooming in/out.

Remarks:

1. (a) could be done as a periodic batch process or by FG on demand, in a background task.

2. tiles for the same area may differ if user has custom scenery installed, therefore a local tile cache would have to be associated with the scenery.

Perhaps 'Atlas' subdirectory in every scenery tree?

3. (b) and (c) could be:

* either local file server (uses user's computer and disk, is always up to date with any scenery they are using),

* or a network tile server (incurs infrastructure cost, possibly feasible only for standard scenery),

* or both.

4. (d) will be heavy on disk space use.

|}

[[Category:Hackathon 2023 Ideas]]

Transponder

2023-05-11T21:59:26Z

MariuszXC: updated volts property

'''Transponders''' are radio beacons which make [[aircraft]] more identifiable on [[ATC]] displays and systems. Modern transponders support transmitting additional data such as an identification ('squawk') code and aircraft altitude. See more at {{wikipedia|Transponder (aeronautics)}}.

== Id Codes ==
Id or 'squawk' codes aid ATC in identify aircraft positively. 1200 is the standard code for VFR flight (in the US; Europe uses 7000), IFR aircraft will typically be advised a code on delivery clearance or startup.

Normal code digits are 0..7; 0000 is reserved for military use, and there are other standard codes, such as 7600 for radio comms failure. See the Wikipedia page for many more examples.

== Modes ==
{{hatnote|For a thorough description, see {{wikipedia|Aviation transponder interrogation modes}}.}}

Civilian Mode-S and Mode-C both transmit pressure altitude (at 10-foot and 100-foot precision, respectively). To do this the transponder needs an altitude source. In real-life this can be a separate box called an encoder, or may be derived for FMC / ADIRU sources. It's important to note this altitude is referenced to standard pressure (29.92 inHg / 1012Hpa), and not corrected for actual barometric pressure in the local environment.

Additional support for military modes is possible if anyone wishes to add it.

== Configuration in FlightGear ==
Transponder support was overhauled in May 2013; earlier versions (2.10 and prior) have different support and are not documented here. Updating an aircraft to use the new config is straightforward. Key transponder properties (altitude, ident and transmitted-id) are now sent via the MP protocols for use in ATC clients.

The default altimeter can act as an altitude encoder; in its configuration, set either or both of the following boolean flags:

* encode-mode-c
* encode-mode-s

The transponder has various config properties:

* '''minimum-supply-volts''': required DV volts for operations, defaults to 8.0 ''(old '''bus-volts''' is now deprecated)''
* '''encoder-path''': defaults to '/instruments/altimeter', but can be changed to any other location. The transponder looks for child properties 'mode-c-alt-ft' and 'mode-s-alt-ft' at this path for altitude data.
* '''kt70-compatibility''': boolean, default to false. Set this to enable legacy compatibility with the old KT-70 C++ instrument. Do not use in new/updated aircraft!
* '''mode''': this is 0 for Mode-A, 1 for Mode-C and 2 for Mode-S. Other modes can be added, ask on the [[Mailing list|devel list]]!

=== Run-time properties ===
* '''altitude''': gives the transmitted altitude in feet (or -9999 for invalid)
* '''altitude-valid''': indicates if altitude value is valid data or not
* '''id-code''': allows the id-code to be read and set
* '''serviceable''': can be set to control the instrument serviceability
* '''transmitted-id''': gives the value being transmitted, including over the network via MP

==== Input properties ====
These live under <tt>/inputs</tt>.
* '''knob-mode''': sets the transponder operating mode. This corresponds to the KT-70 knob positions for convenience, but the actual modes should work for any transponder instrument. Knob modes are documented below
* '''ident-btn''': can be set to place the transponder in ident mode for 18 seconds. Note this property is not spring-loaded, i.e you must manually reset it to false
* '''digit[0]-[4]''': properties allow the id code individual digits to be read and set

In KT-70 compatibility mode, additional properties are read and set, to preserve legacy aircraft. Do not use these properties in new aircraft.

==== Knob/Functional Modes ====
* 0 - off
* 1 - standby, basically the same as off for the C++ code (3D instrument would power up the display, presumably)
* 2 - test, again the C++ largely ignores this since the test configuration of real-world instruments varies. In particular the unit does *not* set altitude or transmitted-id to any test values, you should do that in your own logic. (Maybe we should allow the test values to be defined int he config section?)
* 3 - Ground mode, responds to altitude interrogation but does not broadcast an ID. This would typically be used while taxiing prior to takeoff.
* 4 - On, normal operation but altitude transmission is inhibited
* 5 - Alt, same as on but altitude is broadcast if transponder was configured in Mode-S or Mode-C

=== Generic transponder ===
Below are all available property that you can set for your instrumentation.xml file :

<syntaxhighlight lang="xml">
<transponder>
<name type="string">transponder</name>
<number type="int">0</number>
<mode type="int">1</mode> 
<minimum-supply-volts type="double">8.0</minimum-supply-volts>
<encoder-path type="string">/instrumentation/altimeter</encoder-path>
<kt70-compatibility type="bool">0</kt70-compatibility>
<auto-ground>...</auto-ground> 
<airspeed-path>...</airspeed-path>
<mach-path>...</mach-path>
</transponder>
</syntaxhighlight>Please note that ''<bus-volts>'' is now '''deprecated'''. Use ''<minimum-supply-volts>'' instead.
The following is a copy of a comment in instrument source, explaining the use of Mode-S related properties
<code>
// Mode-S transponders (configured with mode = 2) can transmit a ground bit to
// indicate ground operation. If auto-ground is not defined, the ground bit is
// switched manually by setting the transponder knob to GND. If auto-ground is
// defined, the transponder simulates automatic switching of the ground bit
// using the value of the property defined in auto-ground.
//
// For a squat switch, use "/gear/gear/wow". For automatic switching based on
// airspeed, use a property rule to make a new boolean property that indicates,
// for example, airspeed < 80, and reference your new property in auto-ground.
//
// Note that Mode-A and Mode-C transponders do not transmit a ground bit, even
// if the transponder knob is set to the GND position.
//
// Mode-S transponders also transmit indicated airspeed and Mach number. The
// default sources are "/instrumentation/airspeed-indicator/indicated-speed-kt"
// and ".../indicated-mach", but this can be changed by setting "airspeed-path"
// and "mach-path" properties respectively as shown above.
</code>

==Related content==
===Wiki articles===
*[[Howto:Develop an aircraft transponder in Nasal]] – Most probably obsolete
*[[FLARM]]
*[[Multiplayer protocol]] – The IDs 1501-1503 are earmarked for transmitting transponder properties
*[[OpenRadar: Transponder]]
*[[Traffic alert and collision avoidance system]]

===Forum topics===
*[https://forum.flightgear.org/viewtopic.php?f=4&t=31492 Transponder properties over MP] (January-June 2017)
*[https://forum.flightgear.org/viewtopic.php?f=75&t=19826 Transponder over network] (April-December 2018)
*[https://forum.flightgear.org/viewtopic.php?f=4&t=6395 Transponder] (November 2009-December 2010)

===Developer mailing list===
*[https://sourceforge.net/p/flightgear/mailman/message/30785263/ <nowiki>[</nowiki>Flightgear-devel<nowiki>]</nowiki> Improve tranponder instrument] (Apr 2009)
*[https://sourceforge.net/p/flightgear/mailman/flightgear-devel/thread/1388915221.2195.15.camel%40duter.localdomain/#msg31810053 <nowiki>[</nowiki>Flightgear-devel<nowiki>]</nowiki> Transponder Ident not transmitted via MP Protocol?] (Jan-Feb 2014)

===Source code===
*{{flightgear source|src/Instrumentation/transponder.hxx}}
*{{flightgear source|src/Instrumentation/transponder.cxx}}

[[Category:Aircraft enhancement]]
[[Category:Aircraft instruments]]

Transponder

2023-05-11T21:51:04Z

MariuszXC: /* Generic transponder */ updated with Mode-S related documentation

'''Transponders''' are radio beacons which make [[aircraft]] more identifiable on [[ATC]] displays and systems. Modern transponders support transmitting additional data such as an identification ('squawk') code and aircraft altitude. See more at {{wikipedia|Transponder (aeronautics)}}.

== Id Codes ==
Id or 'squawk' codes aid ATC in identify aircraft positively. 1200 is the standard code for VFR flight (in the US; Europe uses 7000), IFR aircraft will typically be advised a code on delivery clearance or startup.

Normal code digits are 0..7; 0000 is reserved for military use, and there are other standard codes, such as 7600 for radio comms failure. See the Wikipedia page for many more examples.

== Modes ==
{{hatnote|For a thorough description, see {{wikipedia|Aviation transponder interrogation modes}}.}}

Civilian Mode-S and Mode-C both transmit pressure altitude (at 10-foot and 100-foot precision, respectively). To do this the transponder needs an altitude source. In real-life this can be a separate box called an encoder, or may be derived for FMC / ADIRU sources. It's important to note this altitude is referenced to standard pressure (29.92 inHg / 1012Hpa), and not corrected for actual barometric pressure in the local environment.

Additional support for military modes is possible if anyone wishes to add it.

== Configuration in FlightGear ==
Transponder support was overhauled in May 2013; earlier versions (2.10 and prior) have different support and are not documented here. Updating an aircraft to use the new config is straightforward. Key transponder properties (altitude, ident and transmitted-id) are now sent via the MP protocols for use in ATC clients.

The default altimeter can act as an altitude encoder; in its configuration, set either or both of the following boolean flags:

* encode-mode-c
* encode-mode-s

The transponder has various config properties:

* '''bus-volts''': required DV volts for operations, defaults to 8.0
* '''encoder-path''': defaults to '/instruments/altimeter', but can be changed to any other location. The transponder looks for child properties 'mode-c-alt-ft' and 'mode-s-alt-ft' at this path for altitude data.
* '''kt70-compatibility''': boolean, default to false. Set this to enable legacy compatibility with the old KT-70 C++ instrument. Do not use in new/updated aircraft!
* '''mode''': this is 0 for Mode-A, 1 for Mode-C and 2 for Mode-S. Other modes can be added, ask on the [[Mailing list|devel list]]!

=== Run-time properties ===
* '''altitude''': gives the transmitted altitude in feet (or -9999 for invalid)
* '''altitude-valid''': indicates if altitude value is valid data or not
* '''id-code''': allows the id-code to be read and set
* '''serviceable''': can be set to control the instrument serviceability
* '''transmitted-id''': gives the value being transmitted, including over the network via MP

==== Input properties ====
These live under <tt>/inputs</tt>.
* '''knob-mode''': sets the transponder operating mode. This corresponds to the KT-70 knob positions for convenience, but the actual modes should work for any transponder instrument. Knob modes are documented below
* '''ident-btn''': can be set to place the transponder in ident mode for 18 seconds. Note this property is not spring-loaded, i.e you must manually reset it to false
* '''digit[0]-[4]''': properties allow the id code individual digits to be read and set

In KT-70 compatibility mode, additional properties are read and set, to preserve legacy aircraft. Do not use these properties in new aircraft.

==== Knob/Functional Modes ====
* 0 - off
* 1 - standby, basically the same as off for the C++ code (3D instrument would power up the display, presumably)
* 2 - test, again the C++ largely ignores this since the test configuration of real-world instruments varies. In particular the unit does *not* set altitude or transmitted-id to any test values, you should do that in your own logic. (Maybe we should allow the test values to be defined int he config section?)
* 3 - Ground mode, responds to altitude interrogation but does not broadcast an ID. This would typically be used while taxiing prior to takeoff.
* 4 - On, normal operation but altitude transmission is inhibited
* 5 - Alt, same as on but altitude is broadcast if transponder was configured in Mode-S or Mode-C

=== Generic transponder ===
Below are all available property that you can set for your instrumentation.xml file :

<syntaxhighlight lang="xml">
<transponder>
<name type="string">transponder</name>
<number type="int">0</number>
<mode type="int">1</mode> 
<minimum-supply-volts type="double">8.0</minimum-supply-volts>
<encoder-path type="string">/instrumentation/altimeter</encoder-path>
<kt70-compatibility type="bool">0</kt70-compatibility>
<auto-ground>...</auto-ground> 
<airspeed-path>...</airspeed-path>
<mach-path>...</mach-path>
</transponder>
</syntaxhighlight>Please note that ''<bus-volts>'' is now '''deprecated'''. Use ''<minimum-supply-volts>'' instead.
The following is a copy of a comment in instrument source, explaining the use of Mode-S related properties
<code>
// Mode-S transponders (configured with mode = 2) can transmit a ground bit to
// indicate ground operation. If auto-ground is not defined, the ground bit is
// switched manually by setting the transponder knob to GND. If auto-ground is
// defined, the transponder simulates automatic switching of the ground bit
// using the value of the property defined in auto-ground.
//
// For a squat switch, use "/gear/gear/wow". For automatic switching based on
// airspeed, use a property rule to make a new boolean property that indicates,
// for example, airspeed < 80, and reference your new property in auto-ground.
//
// Note that Mode-A and Mode-C transponders do not transmit a ground bit, even
// if the transponder knob is set to the GND position.
//
// Mode-S transponders also transmit indicated airspeed and Mach number. The
// default sources are "/instrumentation/airspeed-indicator/indicated-speed-kt"
// and ".../indicated-mach", but this can be changed by setting "airspeed-path"
// and "mach-path" properties respectively as shown above.
</code>

==Related content==
===Wiki articles===
*[[Howto:Develop an aircraft transponder in Nasal]] – Most probably obsolete
*[[FLARM]]
*[[Multiplayer protocol]] – The IDs 1501-1503 are earmarked for transmitting transponder properties
*[[OpenRadar: Transponder]]
*[[Traffic alert and collision avoidance system]]

===Forum topics===
*[https://forum.flightgear.org/viewtopic.php?f=4&t=31492 Transponder properties over MP] (January-June 2017)
*[https://forum.flightgear.org/viewtopic.php?f=75&t=19826 Transponder over network] (April-December 2018)
*[https://forum.flightgear.org/viewtopic.php?f=4&t=6395 Transponder] (November 2009-December 2010)

===Developer mailing list===
*[https://sourceforge.net/p/flightgear/mailman/message/30785263/ <nowiki>[</nowiki>Flightgear-devel<nowiki>]</nowiki> Improve tranponder instrument] (Apr 2009)
*[https://sourceforge.net/p/flightgear/mailman/flightgear-devel/thread/1388915221.2195.15.camel%40duter.localdomain/#msg31810053 <nowiki>[</nowiki>Flightgear-devel<nowiki>]</nowiki> Transponder Ident not transmitted via MP Protocol?] (Jan-Feb 2014)

===Source code===
*{{flightgear source|src/Instrumentation/transponder.hxx}}
*{{flightgear source|src/Instrumentation/transponder.cxx}}

[[Category:Aircraft enhancement]]
[[Category:Aircraft instruments]]

FGCom-mumble

2023-04-17T15:47:29Z

MariuszXC: /* Servers */

'''FGCom-mumble''' simulates radio communication based on the VoIP software [https://www.mumble.info/ Mumble]. It integrates fully with the radio stack of your FlightGear plane, allowing you to communicate with other pilots and airspace controllers during your flight. It simulates a global, continuous radio frequency spectrum.

FGCom-mumble is an alternative to the already known [[FGCom]] client and [https://forum.flightgear.org/viewtopic.php?t=30691 FGExtend].

FGCom-mumble leverages the plugin mechanism introduced by Mumble 1.4.0 and just needs a precompiled plugin loaded by a stock Mumble client.
You can download the latest release from https://github.com/hbeni/fgcom-mumble/releases.

{{Infobox Software
|title = FGCom-mumble
|logo = FGCom-mumble_logo.png|128px
|developedby = Benedikt Hallinger
|developmentstatus = Active
|type = Radio/Communication
|latestrelease = [https://github.com/hbeni/fgcom-mumble/releases see release page]
|initialrelease = 1.0.0 (17.01.2022)
|writtenin = C++/Lua/Java/PHP
|os = Windows, GNU/Linux, MacOS
|license = [[GNU General Public License]] v3
|website = https://github.com/hbeni/fgcom-mumble
}}

==Servers ==

*The main FGCom-mumble test server is <code>mumble://fgcom.hallinger.org/fgcom-mumble</code>
*The status page for that service showing all connected clients is at: https://fgcom.hallinger.org/
*On first connection Mumble client will ask whether to trust the certificate presented by the server. Currently the server certificate has following details:

<code>Common Name: Murmur Autogenerated Certificate v2</br>
Valid from: Mon. Dec. 7 21:12:40 2020 GMT</br>
Valid to: Sun. Dec. 2 21:12:40 2040 GMT</br>
Serial: 3031</br>
Public Key: 2048 bits RSA</br>
Digest (SHA-1): E6:9A:FA:62:2C:48:4D:73:95:D7:EE:0E:14:0D:5A:C2:AE:14:1C:31</br>
Digest (SHA-256): 50:CE:17:63:FB:FC:40:03:B4:BF:8F:1F:84:35:4C:BA:5D:5C:BE:E4:AD:F9:8C:D8:45:1F:C7:28:EB:CA:3A:C0</code>

It is always a good idea to verify if the signature matches.

==Project main goals==
*Provide communication with geographic and channel separation
*Provide a realistic radio simulation
*Ease of use for the end user/pilot
*Arbitrary frequency support
*ATIS recording and playback
*Radio station broadcast support
*Landline/Intercom support
*RDF detection for clients
*Ease of server side installation and operation
*Standalone nature (no dependency on FlightGear)
* Capability to be integrated into FlightGear, with the option to support third party applications (ATC, but also other flight simulators)
*Modularity, so individual component implementations can be switched and its easy to add features
*Good and complete documentation

== Installation and setup==
The latest release can be fetched from [https://github.com/hbeni/fgcom-mumble/releases GitHub] ([https://github.com/hbeni/fgcom-mumble/actions nightly build] also has debug versions).

The provided [https://github.com/hbeni/fgcom-mumble/blob/master/README.md#install--setup-for-the-client README] has detailed instructions on the needed prerequisites and installation procedures.

Someone even made an install video :) https://www.youtube.com/watch?v=jTRzfVfkgZE and https://www.youtube.com/watch?v=boHsPVTSddk
(thanks mate, well done! however HF is actually simulated already :)

In short:
* Have a stock Mumble client >= 1.4 running, and load the plugin (mumble settings/plugins page)
* Join a channel named `fgcom-mumble` (on a >= 1.4 mumble server)
* Add the `fgfs-addon` folder of the client release as FlightGear Addon in your launcher
* Start FlightGear and use your plane's radio stack (it uses default FGCom buttons, see below)

==Usage==
FlightGear's FGCom-mumble protocol uses the default FGCom buttons:
When you want to talk on COM1 you have to press {{Key press|Space}}. While transmitting you can not hear other pilots trough the used radio (they are half-duplex).
You can also talk on COM2 by pressing {{Key press|Shift|Space}}.
For COM3 you need to define a custom keybind, or use the COMBar (open from ''Menu/Multiplayer/FGCom-mumble'').

If you want to try it out without FlightGear, you can also start the supplied RadioGUI.

=== How to test your setup?===
First, make sure Mumble is working reliably by talking to other people. Either disable the plugin, or be sure you are outside any radio channel (starting with `fgcom-mumble`).

The plugin alters Mumble's receiving audio stream. It adds static noise depending on the radio signal quality, or cancels out all audio when not in range.

If the server supports it (in essence there is a bot-manager running and a `fgcom-recorder-bot` listening) you may do a traditional echo test by tuning `910.00` and start to talk. The radio bot will record that and spawn an echo bot at your position, replaying your message (so you will hear yourself like others will hear you).

===Troubleshooting===
For troubleshooting, refer to the projects [https://github.com/hbeni/fgcom-mumble/blob/master/README.md#troubleshooting README] as it has further suggestions.

===Compatibility ===
FGCom-mumble supports the legacy FGCom UDP protocol and thus should be compatible to clients supporting that. However, it also features some new UDP fields.

*FlightGear is supported through an [https://github.com/hbeni/fgcom-mumble/tree/master/client/fgfs-addon FlightGear addon]. This assumes the default radio implementation and works with at least the C172P and the C182S.
*[[ATC-pie]] has built in support already (be sure to activate "FGCom-mumble" instead of just "FGCom" in the settings).
*[[OpenRadar]] currently supports just COM1 ([https://sourceforge.net/p/openradar/tickets/5/ ticket pending]). To use COM2 and more, you need to either start several mumble instances, or use FGCom-mumble's RadioGUI.
:There is a patched version of OpenRadar with FGCom-mumble and 8.33 channel tuning support available here: http://fgcom.hallinger.org/OpenRadar_fgcom-mumble.jar

====Known incompatibilities====
* The UFO aircraft rebinds {{Key press|Space}} so you can't transmit on the radio. As a workaround you can use the COMBar that comes integrated with the FGFS addon.

==RadioGUI==
The FGCom-mumble RadioGUI is a small Java 8 application that can send the FGCom-mumble UDP messages to the Mumble plugin.

Inside the GUI, you can pick your location from a map and then setup and use your radio stack.
That said, the RadiGUI can be used instead (or additionally to) FGFS to participate on the simulated radio net.

==Server side==
By design, all that is needed is a standard Murmur server (version 1.4.0 or later) and a specially named channel (it has to start with `fgcom-mumble`). This is enough to let the plugin do its work. The entire channel is treated as a single, worldwide continuous radio frequency spectrum.

Additional features are implemented using server side Lua bots (which may run somewhere else):
* ATIS recording and broadcasting
* Radio program broadcasting (OGG playback on a frequency), [https://github.com/hbeni/fgcom-mumble/wiki/How-to-create-a-custom-NDB Custom NDB beacons]
* Status page data collection

A status page showing client details is available as a PHP website, that gets its data fed from the fgcom-status-bot.

Detailed installation and operation documentation is shipped with the releases, but is also [https://github.com/hbeni/fgcom-mumble/blob/master/server/Readme.server.md online].

==How does it work? (technical information)==
The technical details are specified and described in the various readme files of the projects source code (as a starter read the [https://github.com/hbeni/fgcom-mumble/blob/master/Readme.architecture.md Readme.architecture.md]).

Basicly, all users join the same mumble channel and run the fgcom-mumble plugin. The plugin knows everything necessary from the participating users (like radios used, frequencies tuned, locations, etc) and based on that information mutes or plays incoming voice messages from the other users. Based on signal quality, static noise is mixed in for more fun and a more realistic experience.
Because the voice of other users is muted, it is a design wise out-of-the-box feature that brings frequency and location separation but allows everyone to stay in the same mumble channel.

==Related content==
*[https://github.com/hbeni/fgcom-mumble/wiki FGCom-mumble GitHub wiki] with hints etc
*[https://github.com/hbeni/fgcom-mumble/blob/master/README.md FGCom-mumble README.md] Main readme of the project bringing all the details you always wanted to know

===Forum topic===
*The {{forum link|t=37644|title=FGCom-mumble}} has development discussions and release announcements
*{{forum link|p=374950|title=Re: EDDF-Triangle}} and {{forum link|p=374970|title=Re: EDDF-Triangle}} - Compatibility and differences between FGCom, FGCom-mumble and Mumble

===FlightGear Newsletter===
*[[FlightGear_Newsletter_June_2020]]: First prototype announced
*[[FlightGear_Newsletter_July_2020]]: Load tests successful, RDF implemented, Live-Status page added
*[[FlightGear_Newsletter_August_2020]]: More testing, new HF/VHF/UHF models, auto-updater
*[[FlightGear_Newsletter_September_2020]]: Mumble API changes, distributed deployment, configuration trough INI, statistics
*[[FlightGear_Newsletter_October_2020]]: More API changes, proper 8.33kHz/25kHz overlap, RadiGUI added
*[[FlightGear_Newsletter_November_2020]]: Test server announced
*[[FlightGear_Newsletter_December_2020]]: Release 0.8.0 bringing networking capability
*[[FlightGear_Newsletter_April_2021]]: RDF reworked, 0.12.0 announced, MacOS support
*[[FlightGear_Newsletter_May_2021]]: Better airliner support, announced 0.13.0 and 0.14.0, restructured release package structure
*[[FlightGear_Newsletter_June_2021]]: 0.14.1 announced, updater bugfixes
*[[FlightGear_Newsletter_July_2021]]: 0.14.2 announced, updater bugfixes part II
*[[FlightGear_Newsletter_January_2022]]: '''1.0.0 released, Mumble 1.4 hit the light'''

==Screenshots==
<gallery>
Fgcom-mumble_statuspage-0.6.0.png|Statuspage 0.6.0
FGCom-mumble_radioGUI-0.6.0.png|RadiGUI 0.6.0
</gallery>

[[Category:FGCom]]
[[Category:Air Traffic Control]]

K-3D

2022-12-27T11:24:30Z

MariuszXC: updated link

{{Stub}}
'''K-3D''' is a 3D modeling and animation software program that is free [[GPL]] licensed software. [http://www.k-3d.org/ K-3D website here].

== See also ==
* [[Blender]]
* [[Wings 3D]]

== External Links ==
* http://www.k-3d.org/
* http://wiki.k-3d.org/

{{3d}}

[[Category:Software]]
[[Category:Modeling]]
[[Category:GPL software]]

K-3D

2022-12-27T11:23:03Z

MariuszXC: /* External Links */ - corrected links

{{Stub}}
'''K-3D''' is a 3D modeling and animation software program that is free [[GPL]] licensed software. [http://www.k-3d.org/wiki/Main_Page K-3D website here].

== See also ==
* [[Blender]]
* [[Wings 3D]]

== External Links ==
* http://www.k-3d.org/
* http://wiki.k-3d.org/

{{3d}}

[[Category:Software]]
[[Category:Modeling]]
[[Category:GPL software]]

Hardware recommendations

2022-12-23T08:45:54Z

MariuszXC: /* Related content */ - added a reference to OpenGL performance

{{Disclaimer|id=final-fixed-function-release}}

These '''hardware recommendations for [[FlightGear]]''' are based on community feedback, be sure to consult other sources before making serious decisions regarding computer hardware.

The performance of FlightGear depends on three main components in your computer: the CPU (processor), which makes all the computations; the graphics card, which renders the visual aspect of FlightGear, and RAM (also known as memory) which generally allows FlightGear to have more information running (for the lack of a more technical phrase).

You may also want to check out the following article on building your own FlightGear box based on decommissioned and refurbished server at [[Howto: Build a cheap FlightGear box]], and also learn about how the FlightGear project handles old hardware support at [[FlightGear and old Hardware]] - see [[Minimal Startup Profile]] to start with a bare minumum and turn up settings one by one.

Also see: [[FlightGear Benchmark]]

== Recommendations for FlightGear in 2022 (2020.3 LTS) ==
{{Stub|section=yes}}
FlightGear can scale the quality to run on a huge range of hardware at different quality settings.

''Note for old hardware'': Towards the less powerful end of the range, for FlightGear to run smoothly, it requires a video card with OpenGL drivers 2.0 or higher. You need to spend some time learning settings, and tweaking for bottlenecks, to run FlightGear on very old systems. See [[Minimal Startup Profile]] to start with a bare minimum and then turn settings up.

Quick notes:

* The LTS you should be running is the current 2020.3.12+ LTS. (February 2022).

* People buying new hardware with FlightGear in mind are encouraged to wait until LTS ''after'' the current 2020.3 LTS, ''if possible'' - that is, if they imagine they will be using the hardware for a long while so it makes a difference.
*# Future performance requirements will not be known until the LTS after the current LTS. Some of the big projects underway on the FlightGear next branch need to be finished before requirements can be determined. These projects include moving to: the new [[Compositor]] rendering framework, the [[World Scenery 3.0 roadmap|next generation scenery]] rendering and data format, a higher version of OpenGL, in-sim UI replacement, and so on.
*# Hardware prices will be expected to drop once the situation with the pandemic eases. Hardware is getting steadily faster. Hardware with the same performance is getting cheaper. You should never buy hardware for a ''future'' version of FlightGear or any other program. It's always better to wait until the application releases (and until the hardware purchase is justifiable as you have time to start using it properly).
*# There is a 1st rollout of buildings, roads, and objects for the world based on OSM data. Please don't buy hardware based on this rollout. The performance in future rollouts will improve drastically as objects are changed to a newer format. See [[OSM2City 1st Worldbuild]] for details.
* For current hardware requirements (with scenery layers containing the new OSM2City world-build disabled): FlightGear 2020.3 LTS is faster than the 2018.3 LTS. The 2018.3 LTS hardware profile below is valid - but only one profile and hardware build is available in the 2018.3 LTS section as of writing this.
* The DDS texture cache should be turned on:
:<code>[[Qt-launcher|Qt Launcher]] > Settings tab > Rendering > Show more > enable Cache graphics for faster loading</code> '''or''',
:<code>in-sim menu > View > Rendering > enable Use disk space for faster loading (DDS texture cache)</code>.
:The DDS texture cache makes loading faster, and can make the sim feel smoother. it also helps older systems - as it reduces VRAM usage on the Graphics card (GPU), as well as reducing RAM usage. The DDS texture cache will grow in size mainly as you try new aircraft. It will grow in size a bit as you visit new locations, if you have scenery objects like landmarks enabled.
* There is a new graphics profile system being developed for future FlightGear. This will at least have some named settings presets which can be associated with some hardware and performance categories.

== Recommended hardware for FlightGear 2018.3 LTS ==
Only one target performance and settings profile has been written below. Other settings profiles are to-do. FlightGear can scale the quality to run on a huge range of hardware at different quality settings.

''Note for old hardware:'' Towards the less powerful end of the range, for FlightGear to run smoothly, it requires a video card with OpenGL drivers 2.0 or higher. You need to spend some time learning settings, and tweaking for bottlenecks, to run FlightGear on very old systems. See [[Minimal Startup Profile]] to start with a bare minimum and then turn settings up.

Before selecting a GPU and CPU have a look at the benchmark lists in the [[Hardware recommendations#Mostly high and Max settings with 2015.2B mid range GPU|profile]] below for an approximate idea of performance. If you are choosing a laptop see the manufacturers website for that model to find out your GPU and CPU, and check the list. Remember the slowest component will be the limiting component. For example: if you want high graphics but your GPU is slow, having a very fast CPU will not help. Higher resolutions need faster GPUs: for example, you can't run FlightGear at 4k resolution with a laptop if your manufacturer has not included a very fast GPU, even if they have included a reasonably fast dedicated GPU - in these laptops you need to run FlightGear at lower resolution, or find a laptop with faster GPU. If you run out of RAM then you cannot have really high visibility ranges or object densities even if your GPU and CPU is fast. The tips in the sections below about avoiding Intel integrated GPUs, mobile laptop GPUs, and low range NVIDIA GPUs (xx10, xx20, xx30, xx40) apply.

''Note on hardware requirements''

Requirements are only valid for a target FPS, monitor resolution, usage, and graphics / simulation quality settings. People have a huge range of hardware.

For flight simulators the usage can vary depending on the craft used, how the craft is used, and over what scenery the craft is used. The visibility range can change with altitude, and how fast the scenery is loaded can change with speeds. How complex the visuals are depends on how much vegetation, or man-made buildings/objects, are in the visible scenery. The following all place different demands: slow and low with a balloon/[[pterosaur]]/glider/wingsuit/ground effect vehicle, slightly faster and higher in a single prop [[Cessna 172P|C172P]]/[[Cessna 182S|C182]]/[[Piper J3 Cub|Cub]]/[[Piper PA28 Warrior II|PA]], fast and low in a supersonic [[Saab 37 Viggen|Viggen]]/[[Grumman F-14 Tomcat|F-14]] jet, higher altitude but slower in a [[Airbus A320 Family|A320]] airliner, fast and high in a Concorde, extremely fast and high in suborbital craft like the [[X-15]] , or using a [[Space Shuttle|Shuttle]] or [[Vostok-1]] space craft that is fast enough to reach orbit. View distances can vary from [[:File:EC135 Heer.jpeg|individual grass blades]] in airport keep to seeing [[:Category:Screenshots of Earthview|entire continents]] from orbit using a separate orbital renderer. Flying over a dense forest can mean [[:File:Alouette-lll over the Carpathian Mountains in Romania in Autumn (Flightgear 2018.x).jpg|vast]] amounts of trees are in view, while flying over a barren desert or ocean can mean there are few objects. You can always fly with a lower scenery loading distance and/or a lower visibility distance. A cloudless day can mean there are fewer clouds to draw and also may be lighter on CPU to simulate as Advanced Weather tracks lifecyles of individual clouds. On very old systems turning down cloud density and visibility range can help - as can turning off parts of the Advanced Weather simulation, or using basic weather. If you are flying at night using instruments for navigation, you can turn down graphics settings a lot :) . Different craft place different demands on CPU and GPU. Some craft have detailed electrical, electronic, and mechanical systems which are demanding on the CPU to simulate, while a craft like a glider does not. Some craft have high fidelity graphics and complex electronic displays - these can be demanding on the CPU and loading times, not just the GPU!. Some craft have options to reduce graphics. Some craft have options to reduce CPU usage by making parts of the simulation less responsive or less fine-grained - but these craft tend to be craft which are demanding on the CPU to start with.

Tip: If you have a slow GPU or CPU, you may be able to find craft that are less demanding for your bottleneck. Different aspects of craft can be demanding on the GPU or CPU - systems & instruments, aircraft interior art, aircraft exterior art, or flight dynamics model (FDM). For example, some craft may have detailed systems and instruments but have simple interior art. Some research projects just produce a flight dynamics model with no art and simple systems. Don't worry about the CPU time taken by the flight dynamics model - it isn't really heavy on CPU to simulate - think of an offline flight dynamics engine like JSBSim as a photo viewer for digital fine-art - it may take hours, days or weeks to render a fine-art quality ray-traced [https://commons.wikimedia.org/wiki/File:Raytraced_image_of_several_glass_objects.png digital image] but your web browser can display it very quickly - similarly JSBSim can take the results of computational fluid dynamics done on a supercomputing cluster (like a ray-traced digital image), or taken from windtunnel data (like taking a photo), and simulate flight dynamics quite quickly. Tip: You can use the filter in <code>[[FlightGear Qt launcher|FlightGear Qt Launcher]] > Air craft tab > Browse > Filter using ratings > click Adjust minimum ratings</code> ([[FlightGear Qt launcher#Community video walkthroughs|video tutorial]]) to lower minimum ratings and look for craft which have e.g. good systems and flight dynamics model but simpler art - but this only gives a ''small'' clue - some craft like a glider may not have much systems to simulate or have a simple model so they are not demanding even when recreated in detail.

Without target FPS, monitor resolution, usage, and settings, requirements are meaningless other than for maximum settings (i.e. meaningless for what hardware people actually have) - even maximum settings are hard to predict as they depend on what scenery a flight can take place. It's not trivial to find exact specifications, even for commercial applications with lots of test systems. Some commercial 3d applications do give out specifications for less than max settings but these mostly do not give target performance/quality/usage at all, and a lot of 3d applications like games have limited usage patterns making it easier to check - since commercial screenshot galleries tend to be on the most powerful systems at time of release without stating hardware, not giving detailed performance/quality/usage targets is also a way of making people forget quality may not look anything like advertised on their hardware. The topic of quality and performance is not as simple as commercial applications make it out to be in their advertising. People should consider that a bit of time spent tweaking settings for the performance bottlenecks in your hardware, for your typical usages, can make a huge difference to visuals and FPS.

=== Mostly high and Max settings with 2015+ mid range GPU ===

==== Target performance: ====

* '''20-30 FPS''' with default [[Cessna 172P|C172P]]. Monitor resolution 1920 by 1080 (also known as 1080p , Full HD, or FHD).
** Note: actual smoothness depends on frame-spacing spikes - average FPS helps lower overall frame spacing.

==== Target settings: rendering and scenery: ====

* Renderer: [[Atmospheric light scattering|ALS]] (advanced renderer)
* <code>View > rendering</code> dialog:
** Maximum shaders: all shader sliders maxed (i.e. overlays: on).
** Scenery layers: Vegetation density: Very High (if you run into RAM issues try turning this down).
** Scenery layers: Vegetation shadows: on.
** Scenery layers: Buildings: Random buildings - or OSM2City with light scenery near small towns, but not OSM2City near areas dense with big buildings (heavier scenery needs a faster CPU). Tweaking random building density: Try setting<code>/sim/rendering/building-density</code> in the range of 1-10. You can set this in the [[property browser]], or as a [[Command line options|command-line option]] set in various ways including the [[FlightGear Qt launcher|Qt launcher]],
** Scenery layers: everything else on: Scenery objects (includes airport terminals), roads and railways, pylons, random scenery objects
** Cloud density and visibility range sliders: max.
* <code>View menu > Adjust LOD ranges</code> dialog
**[[Level Of Detail (LOD) Ranges#Scenery ranges|Level of detail ranges]]: default (single prop planes): 1.5km/9km/30km.
* [[Anti-aliasing]]: 4x or 8x Multi-sampling(MSAA). [[Anti-aliasing#Transparency anti-aliasing|Transparency anti-aliasing]] (called Adaptive anti-aliasing on AMD GPUs): Multisample.

* <code>Environment > weather > detailed weather</code> dialog:
**[[Weather#Advanced Weather|Advanced Weather]]: on.
** [[Weather#Advanced configuration|Advanced settings]] dialog: Enabled features: All: <code>Cloud shadows</code>, <code>Realistic visibility</code>, <code>Generate thermals</code>, <code>Terrain effects</code>, <code>Terrain pre-sampling</code>, etc. <code>Max visibility</code> : 250km

=== Hardware build: ===

* '''GPU''' (Graphics Processing Unit, or Graphics Card): A GTX 960 or 1050 Ti - or equivalent performance. More than 3000 ratings in this list: as of [http://web.archive.org/web/20210412095421/https://benchmarks.ul.com/compare/best-gpus April 2021]. [https://benchmarks.ul.com/compare/best-gpus Direct link] (Note: ratings numbers and list may have changed by the time you see it). Note: a GPU with this performance is capable of much more than 30 FPS.
* '''CPU''': 4 core Intel Sandybridge [https://en.wikipedia.org/wiki/Sandy_Bridge#Desktop_platform i5 2500] (released 2012) or faster. This build will be '''limited by the CPU''' . Try to get a newer generation [https://en.wikipedia.org/wiki/Intel_Core Intel CPU], or equivalent AMD Ryzen CPU, if possible - e.g. a 4th generation Intel [https://en.wikipedia.org/wiki/Haswell_(microarchitecture)#Desktop_processors Haswell] (4xxx) i5 CPU, or faster. For a fairly approximate idea of CPU performance needed (Sandybridge i5 2500 has a rating of ~1700) see this archived copy of a single-core benchmark list: [http://web.archive.org/web/20210412100323/https://www.cpubenchmark.net/singleThread.html April 2021] . [https://www.cpubenchmark.net/singleThread.html Direct link] (Note: this direct list may have changed ratings numbers by the time you see it). This list only gives single-core performance - and it is approximate - for example, when an application uses more than one core processor the frequency will drop slightly lowering performance. The only reason a 2012 Sandybridge 2500 can manage 20-30FPS is because core performance hasn't gone up that much - it has increased by about 2x. FlightGear uses multiple cores. Some people may be able to get FG to run fine with a fast high clock 2 core CPU from a newer generation of CPU. But a 4 core is recommended as future FlightGear will use cores even more.

*'''Memory''' (RAM): 8GB (12-16 GB preferred). If you lack RAM you need to reduce the level of detail ranges so less scenery is displayed.
*'''Disk:''' to do! .

=== FlightGear settings tips: ===

* This build is '''limited by CPU'''. If your CPU is not faster (newer generation), at least you can try turning up graphics more to give the GPU something to do (try increasing Anti-aliasing, turning up transparency anti-aliasing by selecting super-sampling variety, increasing tree density).
* GPU limited: Try turning down the resolution and [[anti-aliasing]] if you are GPU limited. The higher the resolution the more work the GPU must do. A 4k (UHD) resolution is like the pixel shader load of rendering on four 1080p screens at once! See [[Anti-aliasing#The%20trade%20off%20between%20graphics%20content.2C%20FPS.2C%20and%20graphics%20settings%20like%20anti-aliasing|The trade off between graphics content, FPS, and graphics settings like anti-aliasing]]
* GPU: For '''4k monitors''': Try reducing resolution to 1080p. A lot of laptops come with slow GPUs but have 4k screens. You should try the equivalent of a GTX 1080/2070 or a rating of about 7800 in this archived list, but you may have to tweak settings a bit: [http://web.archive.org/web/20210412095421/https://benchmarks.ul.com/compare/best-gpus April 2021]. [https://benchmarks.ul.com/compare/best-gpus Direct link] (Note: ratings numbers and list may have changed by the time you see it). See the advice on the [[Anti-aliasing#Tips on using anti-aliasing settings|anti-aliasing]] page.
** Notes: It's overlays and tree density that can put stress on the GPU.
* GPU: overlays require strong GPU power (that level of detail is not trivial).
* CPU: Aircraft that are heavier on CPU than than the C172P can drag down performance more if you are CPU limited.
* RAM & GPU: Trees at ultra consume a lot of RAM. They need GPU power too.
* RAM: If you run into RAM issues try turning down : [[Level Of Detail (LOD) Ranges#Scenery ranges|LoD:Rough]] (in <code>View menu > Adjust LOD range</code>), tree density, and LoD: bare.
* CPU & RAM: Using OSM2City scenery can also use up RAM and CPU. OSM2City version 2017.2 is compatible with FlightGear 2018.3 LTS. Try turning off roads and pylons if you are CPU limited. Try turning down LoD:rough if you are RAM/CPU limited. Random scenery objects can be heavy on CPU, try turning them off.
* GPU: ALS shaders sliders can be maxed in a lot dedicated GPUs, even quite old ones provided they are dedicated GPUs (and not integrated/mobile GPUs). It's mostly the scenery layer settings including tree density and LoD ranges that can be intensive.
* GPU / Disk space: turn on the <code>View > rendering > texture cache</code> for smoother FPS frame spacing and faster loading. This will take up extra space.
* ...what does this look like? Only the screenshots that have been uploaded to the wiki by volunteers are available right now. There is a wiki category with '''roughly''' [[:Category:Screenshots at high settings|high settings screenshots]]. Note: a lot of these screenshots use settings that are below this profile, the overlays screenshots typically have transparency anti-aliasing higher than multisampling, some screenshots are with a much older FlightGear, a substantial amount of screenshots laptops with weaker GPUs or computers with less than 16 GB of RAM, some screenshots are at slightly higher settings than this profile or at 4k resolution.To get to the highest settings in the category at 1080p and trees at ultra, you would need a GTX 1060 or higher (about [http://web.archive.org/web/20210314111800/https://benchmarks.ul.com/compare/best-gpus 4100] in ratings), 12-16 GB of RAM - lowering LoD ranges will help (low ranges are fine for low altitude flights especially in mountain areas). Not turning up transparency AA will help. The CPU would be maybe a bit faster than i5 2500 to populate trees quickly at ultra e.g. a fast Haswell i5, or an overclocked Sandybridge i5 2500k @ close to 5GhZ.

== Recommended hardware for FlightGear 3.20+ ==
{{See also|SIMD Support}}
Generally, if you want to see frame rates in the 20's and above and medium/high graphical settings, which is typically preferred, you should have a budget of at least $1000. The following list is recommended hardware. It is not required to any degree; however, if you're purchasing a new computer dedicated to FlightGear, it is highly recommended that you get a computer with at least these requirements.
; Display
* A screen with a resolution of at least 1024x768 @32bpp (most GUI dialogs cannot be used otherwise currently)
; Graphics processing unit
* A 3D video card (with AMD or NVIDIA chipset) with support for [[OpenGL]] 2.1 or better and at least 1024-2048MB of dedicated DDR3+ (DDR5 preferred) VRAM (i.e. 512 Mb VRAM minimum). FlightGear requires an '''OpenGL 2.1-compliant''' hardware-accelerated 3D video card to run at reasonable frame-rates. Most modern PCs have hardware-accelerated 3D cards. If your FlightGear video is not running smoothly, see [[Graphics drivers configuration]].
* See [[Supported Video Cards]] for a list of video cards known to work with FlightGear.
* Cards with working GLSL/shader support will enable FlightGear to run with more visual effects.
* If you are serious about running FlightGear, you should [[Problematic Video Cards#Intel GMA|avoid Intel HD/GMA cards]] at all costs - these are integrated chipsets that provide only basic OpenGL/GLSL support. See [[problematic video cards]] for a list of video cards that may not properly run.
; Processor
* At least 2-4 Gb '''free''' RAM (and more is better: when building/buying a new system, consider 6-8gb total the absolute minimum these days). FlightGear uses more than 500 Mb of RAM by default. If less free RAM is available, FlightGear would be slowed down significantly due to OS swapping.
* At least a quad core processor with ~ 2 GHz each, 64 bit architecture (and operating system) recommended (multi-core processors have benefits for some FlightGear components such as the threaded tile loader). When buying a new computer, buying at least a quad core computer (i.e. i7) is a good idea these days.
; Storage disk
* 5 Gb HD space for a minimum installation, approx. 10 Gb if you want to compile it yourself, plus up to 80 Gb for optional world-wide scenery. More space is required for people wanting to check out the latest base package from [[Git]]. People using [[Scripted Compilation on Linux Debian/Ubuntu]], will approximately need 30 Gb of disk space in total.
; Input devices
* A three button mouse or two button mouse with scroll wheel
* An optional [[joystick]]/yoke and/or pedals - Gameport or USB (HID compatible), see <tt>[[$FG_ROOT]]/Input</tt> for a list of input hardware known to work with FlightGear.
; Sound card
* An optional sound card, Soundblaster compatible, preferably with EAX support.

== NVIDIA ==
''April 2021 note:'' Check a GPU benchmark list like this for a '''rough''' idea of performance: [https://benchmarks.ul.com/compare/best-gpus Direct link] ([http://web.archive.org/web/20210412095421/https://benchmarks.ul.com/compare/best-gpus April 2021 archive]). If you are selecting a laptop find out what your GPU is - ask or check the manufacturers website page for the model of the laptop. Laptop GPUs: Laptops with NVIDIA 9xx and earlier series GPUs often have the mobile "M" variant. These are a lot slower than the normal version e.g. a GTX 960M is slower than a GTX 960. NVIDIA 10xx series and later use desktop equivalents in all laptops, or close to it. This is due to recent GPU technology using less power making it easier on laptop batteries. There are also Q-MAX variants that are only slightly slower than normal versions but use less battery - e.g. a GTX 1060 Q-MAX is only slightly slower than a GTX 1060 - see benchmarks. (April 2021)

Recent NVIDIA price/performance trends (March 2021):

* Each GPU slot tends to get the performance of the GPU slot above it from the last generation. e.g. A GTX 1650 (xx50 slot) will get the a the performance of a GTX 1060 (xx60 slot).
* The price and performance sweet spot are the midrange cards xx50, XX50 Ti and xx60. xx50 Ti might be around the best slot.
* The fastest cards are released first each GPU generation (e.g. xx80 Ti or xx90), and are priced high to sell to enthusiasts - for GPU chips yields are also low to start so there's a limited number of hardware.GPUs are released in decreasing order of performance to tempt people to buy a performance range that they don't need. AMD follows the same pattern.
* Hardware prices are expected to drop as the situation with the global pandemic eases.

Stay away from nVidia GPUs with a low second digit (x20, xx20, x40, xx40). Higher 2nd digit means more CUDA cores.

The number of CUDA cores matters much more than a few Mhz in frequency, since you can process more, in parallel.
Also watch out for bus width, as that has a big impact on data throughput. The more CUDA cores it has, the better. A GTX680 is lots and lots and lots more important than a CPU with a zillion cores.

In case of doubt, go for an older generation x60 (460, or 560), even a 260 would be much more of an improvement than the 620. Basically, Nvidia cards compile GLSL shaders and OpenCL kernels into CUDA kernels (sort of), so more CUDA kernels = more shader power.

Whatever GPU (and other hardware) you get, first of all make sure that it is fully supported by your OS of choice.
Thorsten mentioned in another thread that he purchased a computer with an NVIDIA GTX670 that ended up not being fully supported under Linux, so I'd suggest to be really careful here.

== Notebooks ==
If you are interested in running FlightGear on a notebook, you may also want to check out [[Notebooks known to run FlightGear]]. A regular notebook is not recommended if you plan to fly often on FlightGear.

== Components ==
Your overall experience on FlightGear generally depends on these components:
*Your '''CPU''', which makes all the calculations. This component isn't as important as your graphics card. However, you should keep in mind that your CPU is the brain of your computer. As stated above, it's recommended that you purchase a CPU that has at least 4 cores.
*Your '''graphics card''', which renders the visuals of FlightGear. This component is extremely important. If you have an amazing CPU but a lackluster graphics card, your framerate will be low. Also, it's recommended that you purchase a relatively new graphics card, as old ones (even if very powerful) have been known to cause rendering glitches.
*Your '''RAM''' (memory), which allows temporary storage of information. Memory is probably least important of the three when it comes to framerate; however, any less than 4 GB memory has been known to cause crashes in FlightGear.

=== Should I purchase a computer or build my own? ===
It is generally recommended that you build your own computer. Your money will get you much farther. However, it is also recommended that if you build your own computer, you know someone who knows their way around computers. Buying parts that you ''think'' may be powerful but truthfully are not, or worse case, not compatible, can lead to disappointment.

== Related content ==
* [[Supported Video Cards]]
* [[Graphics drivers configuration]]
* [[OpenGL_performance]]
* [[Troubleshooting Problems]]

[[Category:Articles to be updated for each release]]
[[Category:Hardware|Recommendations]]

[[de:Hardwareempfehlungen]]
[[es:Recomendaciones de hardware]]
[[fr:Hardware Recommendations]]
[[pl:Wymagania sprzętowe]]

Howto:Write a fuel system in JSBSim

2022-11-28T15:30:08Z

MariuszXC: Added a note clarifying the meaning of a pps unit.

As of [[FlightGear]] 2.4.0, JSBSim aircraft have a new tank-property: <tt>propulsion/tank[n]/external-flow-rate-pps</tt>. Setting this property will either draw fuel from (value < 0), or insert fuel into (value > 0) the respective tank. By using this property, one can simulate complex fuel systems. Note: [pps] stands for pounds per second.

== A fuel system file ==
First we create a system file, in which we will write the actual system. It's advised to save this file as <tt>Aircraft/.../Systems/fuel.xml</tt>.
<syntaxhighlight lang="xml">
<?xml version="1.0"?>

<system name="fuel">

</system>
</syntaxhighlight>

We link the main FDM to this system by adding the following line, somewhere in your aircraft's FDM (I advise to put it below <tt></propulsion></tt>).
<syntaxhighlight lang="xml">
<system file="fuel"/>
</syntaxhighlight>
Notice how "fuel" refers to <tt>Aircraft/.../Systems/fuel.xml</tt>.

== Fuel handling in JSBSim ==
To make JSBSim handle the fuel system during simulation we create one or more channels in the system file. Within these we can use the different control components [http://jsbsim.sourceforge.net/JSBSimReferenceManual.pdf available in JSBSim].

When using <tt>propulsion/tank[n]/external-flow-rate-pps</tt> there is no automatic detection if the tank is full or empty. Fuel filling an already full tank will just disappear, creating a "leak". Fuel drawn from an empty tank will make new fuel magically appear in the system. In most cases we will have to make checks to avoid these problems.

Two control components that is useful in a fuel system are summers and switches.

=== Summers ===
To calculate the total fuel-flows to/from each tank, we need to sum up the independent flows. This must be done for each single tank, but the principle is the same every time and simple to understand. Every flow that transports fuel ''from'' a tank should get a minus sign.

This summer calculates the total flow to or from tank[0].
<syntaxhighlight lang="xml">
<summer>
<input>-propulsion/tank[0]/external-flow-rate/jettison</input> 
<input>-propulsion/tank[0]/external-flow-rate/tank[1]</input> 
<input>-propulsion/tank[0]/external-flow-rate/tank[2]</input> 
<input>-propulsion/tank[0]/external-flow-rate/tank[3]</input> 
<input>propulsion/tank[1]/external-flow-rate/tank[0]</input> 
<input>propulsion/tank[2]/external-flow-rate/tank[0]</input> 
<input>propulsion/tank[3]/external-flow-rate/tank[0]</input> 
<output>propulsion/tank[0]/external-flow-rate-pps</output>
</summer>
</syntaxhighlight>

=== Switches ===
To turn the flow on or off we need a switch.

This switch draws 5 lbs/s from tank[0] until its empty as long as the collector vale is open.
<syntaxhighlight lang="xml">
<switch>
<default value="-5"/>
<test logic="OR" value="0">
propulsion/tank[0]/collector-valve EQ 0
propulsion/tank[0]/pct-full LE 0
</test>
<output>propulsion/tank[0]/external-flow-rate-pps</output>
</switch>
</syntaxhighlight>

== Examples ==
=== Jettison switch ===
The /controls/fuel/fuel-to-remain property controls the amount of fuel (in lbs) that should be kept a board. When the total-fuel-level reaches that level, fuel dumping will auomatically stop. Fuel dumping can also be stopped by closing the jettison valves (disable <tt>/controls/fuel/dump-valve</tt>).
<syntaxhighlight lang="xml">
<switch>
<default value="0"/>
<test logic="AND" value="12.25">
/controls/fuel/dump-valve == 1
propulsion/total-fuel-lbs gt /controls/fuel/fuel-to-remain
</test>
<output>propulsion/tank[0]/external-flow-rate/jettison</output>
<output>propulsion/tank[2]/external-flow-rate/jettison</output>
<output>propulsion/tank[3]/external-flow-rate/jettison</output>
<output>propulsion/tank[7]/external-flow-rate/jettison</output>
</switch>
</syntaxhighlight>
The output properties should be added as inputs to the respective summers. Add a minus sign, as the fuel is taken ''from'' the tank.

=== Two tanks and a collector tank ===
A system with two tanks (tank[0] and tank[1]) feeding a collector tank (tank[2]). The engine is fed from the collector tank. There is valves between each of the tanks and the collector that can be set open or closed. Negative Gs cut the supply to the collector.

The system consists of two properties: propulsion/tank[0]/collector-valve and propulsion/tank[1]/collector-valve that represent the valves and a channel that handles the fuel transfer from the tanks to the collector and the necessary checks.

The fuel transfer using external-flow-rate-pps does not check against if tanks are empty or full. This can create fuel when "fuel" is drawn from an empty tank or a "leak" when fuel is pumped into a full tank. The collector tank in the example has the capacity 130 lbs so making the check against collector tank level greater or equal to 129 instead of against 130 is done to avoid the later kind of leak since the collector tank normally receives more fuel every time step than the engine uses. The 1 lb margin creates a buffer for this difference as the value oscillates around 129 lbs as the switch turns on and off the flow.

[[File:Collector-tank-system2.png|thumb|Two tanks and a collector tank]]
<syntaxhighlight lang="xml">
<?xml version="1.0"?>

<system name="Fuel">


<property value="1">propulsion/tank[0]/collector-valve</property>
<property value="1">propulsion/tank[1]/collector-valve</property>

<channel name="Fuel pumping">

<switch>
<default value="-5"/>
<test logic="OR" value="0">
propulsion/tank[0]/collector-valve EQ 0
propulsion/tank[0]/contents-lbs LE 0
propulsion/tank[2]/contents-lbs GE 129 
accelerations/Nz LE -0.5
</test>
<output>propulsion/tank[0]/external-flow-rate-pps</output>
</switch>

<switch>
<default value="-5"/>
<test logic="OR" value="0">
propulsion/tank[1]/collector-valve EQ 0
propulsion/tank[1]/contents-lbs LE 0
propulsion/tank[2]/contents-lbs GE 129 
accelerations/Nz LE -0.5
</test>
<output>propulsion/tank[1]/external-flow-rate-pps</output>
</switch>

<summer>
<input>-propulsion/tank[0]/external-flow-rate-pps</input>
<input>-propulsion/tank[1]/external-flow-rate-pps</input>
<output>propulsion/tank[2]/external-flow-rate-pps</output>
</summer>

</channel>

</system>

</syntaxhighlight>

=== Spitfire: Carburetor engine ===

Spitfire II fuel system. This systems have properties for damage, leaks and simulates the carburetor as a small tank to handle fuel starvation at negative Gs.
The Spitfire has two interconnected tanks with fuel flowing from an upper tank to a lower and both connected to the engine through cocks. The layout of the system can be seen [http://616sqn.tidesofwar.net/gallery/spitfuelsm.jpg here].

<syntaxhighlight lang="xml">
<?xml version="1.0"?>

<system name="Fuel">

<property value="0"> /fdm/jsbsim/fuel/tank_top_cock</property>
<property value="0"> /fdm/jsbsim/fuel/tank_bottom_cock</property>
<property value="1"> /fdm/jsbsim/fuel/damage</property>
<property value="0"> /fdm/jsbsim/fuel/priming</property>
<property value="0"> /fdm/jsbsim/fuel/leak_top_tank</property>
<property value="0"> /fdm/jsbsim/fuel/leak_bottom_tank</property>

<channel name="carburetor">


<summer name="fuel/float_chamber-pps">
<input>fuel/pump_flow_to_float-pps</input>
<input>/fdm/jsbsim/fuel/priming</input>
<input>-propulsion/engine/fuel-flow-rate-pps</input>
<output>propulsion/tank[0]/external-flow-rate-pps</output>
</summer>

</channel>

<channel name="Fuel Pump">


<aerosurface_scale name="fuel/float_throttle-valve-cmd">
<input>propulsion/tank[0]/contents-lbs</input>
<zero_centered>false</zero_centered>
<domain>
<min>0.0</min>
<max>0.5</max>
</domain>
<range>
<min>1.0</min>
<max>0.0</max>
</range>
</aerosurface_scale >


<switch name="fuel/flowing_from_tank">
<default value="0"/>
<test logic="AND" value="fuel/float_throttle-valve-cmd">
accelerations/Nz GE -0.5
<test logic="OR">
<test logic="AND">
fuel/tank_top_cock EQ 1
propulsion/tank[1]/contents-lbs GT 0
</test>
<test logic="AND">
fuel/tank_bottom_cock EQ 1
propulsion/tank[2]/contents-lbs GT 0
</test>
</test>
</test>
</switch>

<fcs_function name="fuel/pump_flow_to_float-pps">
<function>
<product>
<property>fuel/flowing_from_tank</property>
<table> 
<independentVar>propulsion/engine/engine-rpm</independentVar>
<tableData> 
0 0
100 1
3000 10
</tableData>
</table>
<property>fuel/damage</property>
<value>0.12</value> 
</product>
</function>
<output>fuel/pump_flow_to_float-pps</output>
</fcs_function>

</channel>

<channel name="Tanks">


<fcs_function name="fuel/flow_from_tank">
<function>
<quotient>
<property>fuel/pump_flow_to_float-pps</property>
<sum>
<property>fuel/tank_top_cock</property>
<property>fuel/tank_bottom_cock</property>
</sum>
</quotient>
</function>
<output>fuel/flow_from_tank</output>
</fcs_function>

</channel>

<channel name="Top Tank">


<switch name="fuel/top_bottom_transfer">
<default value="0"/>
<test logic="AND" value="1">
propulsion/tank[1]/contents-lbs GT 0
propulsion/tank[2]/contents-lbs LT 322
accelerations/Nz GE -0.5
</test>
</switch>


<fcs_function name="fuel/top_bottom_transfer-pps">
<function>
<product>
<property>fuel/top_bottom_transfer</property>
<sum>
<property>fuel/from_bottom_tank</property>
<table> 
<independentVar>propulsion/tank[2]/contents-lbs</independentVar>
<tableData>
319 1
322 0
</tableData>
</table>
</sum>
</product>
</function>
<output>fuel/top_bottom_transfer-pps</output>
</fcs_function>


<switch name="fuel/from_top_tank">
<default value="0"/>
<test logic="AND" value="fuel/flow_from_tank">
fuel/tank_top_cock EQ 1
accelerations/Nz GE -0.5
</test>
</switch>


<summer name="fuel/total_from_top_tank-pps">
<input>-fuel/top_bottom_transfer-pps</input>
<input>-fuel/from_top_tank</input>
<input>-fuel/leak_top_tank</input>
<output>propulsion/tank[1]/external-flow-rate-pps</output>
</summer>

</channel>

<channel name="Bottom Tank">


<switch name="fuel/from_bottom_tank">
<default value="0"/>
<test logic="AND" value="fuel/flow_from_tank">
fuel/tank_bottom_cock EQ 1
accelerations/Nz GE -0.5
</test>
</switch>


<summer name="fuel/total_from_bottom_tank-pps">
<input>fuel/top_bottom_transfer-pps</input>
<input>-/fdm/jsbsim/fuel/priming</input>
<input>-fuel/from_bottom_tank</input>
<input>-fuel/leak_bottom_tank</input>
<output>propulsion/tank[2]/external-flow-rate-pps</output>
</summer>

</channel>

</system>
</syntaxhighlight>

=== Douglas DC3 (2 engines, 4 tanks) ===
The real aircraft has two engines and four tanks.Two tank selectors (one per engine) allows each engine to be fed by each tank, separately and one tank at a time for a given engine. The diagram of the fuel system can be seen [http://2.bp.blogspot.com/-t6PpgjQXPGw/Ul60qTdgJDI/AAAAAAAAAmU/iefht14OnzQ/s1600/DC-3+fuel+system.jpg in this document].
For FG, the engines are numbered [0] and (1], the 'true' feed tanks [0], [1], [2], [3]. Each tank selector is a 5-positions ('OFF' + 4 tanks) rotary switch. Its positions are numbered -1 (= 'OFF'), 0, 1, 2, 3, respectively for 'no tank selected', tank[0], [1], [2], [3].

'''Prerequisite''': A nasal code logic says:
* if an engine[N] boost-pump is "ON", and fuel-level > 4 lbs in the tank selected for this engine[N] ==> fuel-pressure = 16 psi
* else, if engine[N] is running, and fuel-level > 4 lbs in the tank selected for this engine[N] ==> fuel-pressure = 14.5
* else of all that, fuel-pressure = 0
Hence, fuel pressure is a a good criteria to tell that an engine is fed or not, i.e. if it is connected to a tank, if this tank is not empty, with a running pump (or not).

(This function above could probably be implemented by XML)

'''For the fuel system presented here''', two small collector tanks [4] and [5] (each collector tank feeding one engine) have been added. In JSBSim, for this multi-engine aircraft (differently from a single-engine one), these collector tanks are necessary to have each engine be separately fed by its selected 'true' tank and selectively stop if the tank runs out of fuel. The collector tanks are fed by the selected tanks (through rotary switches for left and right engines) and have their level kept constant. This functioning is close to a constant level carburetor.

'''The FDM''' contains the following lines which set the tanks.
Notice that the engines are written as fed by the collector tanks ([4] and [5]), which themselves will be fed by the selected 'true' tanks ([0] to [3]).
<syntaxhighlight lang="xml">
<propulsion>
<engine file="DC3_engine"> 
.........
<feed>4</feed>
.........
</engine>

<engine file="DC3_engine"> 
.........
<feed>5</feed>
.........
</engine>

<tank type="FUEL" number="0">
.........
<capacity unit="LBS"> 1202 </capacity>
<contents unit="LBS"> 600 </contents>
</tank>

<tank type="FUEL" number="1">
...........
<capacity unit="LBS"> 1210 </capacity>
<contents unit="LBS"> 600 </contents>
</tank>

<tank type="FUEL" number="2">
...........
<capacity unit="LBS"> 1210 </capacity>
<contents unit="LBS"> 600 </contents>
</tank>

<tank type="FUEL" number="3">
...............
<capacity unit="LBS"> 1202 </capacity>
<contents unit="LBS"> 600 </contents>
</tank>

<tank type="FUEL" number="4">

...........
<capacity unit="LBS"> 0.5 </capacity>
<contents unit="LBS"> 0 </contents>
</tank>

<tank type="FUEL" number="5">

..............
<capacity unit="LBS"> 0.5 </capacity>
<contents unit="LBS"> 0 </contents>
</tank>

</propulsion>
</syntaxhighlight>

The '''Fuel system XML file''' itself is shown below (can be named fuel.xml, see at the top of this document for how to link the FDM to it).

Collector tanks [4] and [5] have their level kept constant (at 0.25 lb content) by a step-controlled input flow rate (0 or 0.5 pps here). The "ON" value of this step flow rate must be a bit higher than the maximum" fuel-flow-rate-pps" needed by each engine at full power.

Collector tanks [4] and [5] content is a compromise. A large content is secure but it gives an excessive delay between the moment when the 'true' tank runs out of fuel and the engine effectively stops running.

<syntaxhighlight lang="xml">
<?xml version="1.0"?>



<system name="fuel">





<channel name="Engine 0 Rotary Left Valve Logic">





<switch name="fuel/through-left-valve">
<default value="0"/>
<test logic="AND" value="0.5">
/controls/fuel/left-valve EQ 0
propulsion/tank[0]/contents-lbs GT 0
/consumables/fuel/tank[4]/level-lbs LT 0.25
/engines/engine[0]/fuel-psi-norm GT 5
</test>
<test logic="AND" value="0.5">
/controls/fuel/left-valve EQ 1
propulsion/tank[1]/contents-lbs GT 0
/consumables/fuel/tank[4]/level-lbs LT 0.25
/engines/engine[0]/fuel-psi-norm GT 5
</test>
<test logic="AND" value="0.5">
/controls/fuel/left-valve EQ 2
propulsion/tank[2]/contents-lbs GT 0
/consumables/fuel/tank[4]/level-lbs LT 0.25
/engines/engine[0]/fuel-psi-norm GT 5
</test>
<test logic="AND" value="0.5">
/controls/fuel/left-valve EQ 3
propulsion/tank[3]/contents-lbs GT 0
/consumables/fuel/tank[4]/level-lbs LT 0.25
/engines/engine[0]/fuel-psi-norm GT 5
</test>
<output>propulsion/tank[4]/external-flow-rate-pps</output> 
</switch>




<switch name="fuel/from-tank0-to-tank4">
<default value="0"/>
<test value="-fuel/through-left-valve">
/controls/fuel/left-valve EQ 0
</test>
</switch>


<switch name="fuel/from-tank1-to-tank4">
<default value="0"/>
<test value="-fuel/through-left-valve">
/controls/fuel/left-valve EQ 1
</test>
</switch>


<switch name="fuel/from-tank2-to-tank4">
<default value="0"/>
<test value="-fuel/through-left-valve">
/controls/fuel/left-valve EQ 2
</test>
</switch>


<switch name="fuel/from-tank3-to-tank4">
<default value="0"/>
<test value="-fuel/through-left-valve">
/controls/fuel/left-valve EQ 3
</test>
</switch>

</channel>





<channel name="Engine 1 Rotary Right Valve Logic">





<switch name="fuel/through-right-valve">
<default value="0"/>
<test logic="AND" value="0.5">
/controls/fuel/right-valve EQ 0
propulsion/tank[0]/contents-lbs GT 0
/consumables/fuel/tank[5]/level-lbs LT 0.25
/engines/engine[1]/fuel-psi-norm GT 5
</test>
<test logic="AND" value="0.5">
/controls/fuel/right-valve EQ 1
propulsion/tank[1]/contents-lbs GT 0
/consumables/fuel/tank[5]/level-lbs LT 0.25
/engines/engine[1]/fuel-psi-norm GT 5
</test>
<test logic="AND" value="0.5">
/controls/fuel/right-valve EQ 2
propulsion/tank[2]/contents-lbs GT 0
/consumables/fuel/tank[5]/level-lbs LT 0.25
/engines/engine[1]/fuel-psi-norm GT 5
</test>
<test logic="AND" value="0.5">
/controls/fuel/right-valve EQ 3
propulsion/tank[3]/contents-lbs GT 0
/consumables/fuel/tank[5]/level-lbs LT 0.25
/engines/engine[1]/fuel-psi-norm GT 5
</test>
<output>propulsion/tank[5]/external-flow-rate-pps</output> 
</switch>




<switch name="fuel/from-tank0-to-tank5">
<default value="0"/>
<test value="-fuel/through-right-valve">
/controls/fuel/right-valve EQ 0
</test>
</switch>


<switch name="fuel/from-tank1-to-tank5">
<default value="0"/>
<test value="-fuel/through-right-valve">
/controls/fuel/right-valve EQ 1
</test>
</switch>


<switch name="fuel/from-tank2-to-tank5">
<default value="0"/>
<test value="-fuel/through-right-valve">
/controls/fuel/right-valve EQ 2
</test>
</switch>


<switch name="fuel/from-tank3-to-tank5">
<default value="0"/>
<test value="-fuel/through-right-valve">
/controls/fuel/right-valve EQ 3
</test>
</switch>

</channel>





<channel name="Total flow rates">

<summer name="fuel/tank0-flow-rate">
<input>fuel/from-tank0-to-tank4</input>
<input>fuel/from-tank0-to-tank5</input>
<output>propulsion/tank[0]/external-flow-rate-pps</output>
</summer>

<summer name="fuel/tank1-flow-rate">
<input>fuel/from-tank1-to-tank4</input>
<input>fuel/from-tank1-to-tank5</input>
<output>propulsion/tank[1]/external-flow-rate-pps</output>
</summer>

<summer name="fuel/tank2-flow-rate">
<input>fuel/from-tank2-to-tank4</input>
<input>fuel/from-tank2-to-tank5</input>
<output>propulsion/tank[2]/external-flow-rate-pps</output>
</summer>

<summer name="fuel/tank3-flow-rate">
<input>fuel/from-tank3-to-tank4</input>
<input>fuel/from-tank3-to-tank5</input>
<output>propulsion/tank[3]/external-flow-rate-pps</output>
</summer>

</channel>

</system>
</syntaxhighlight>

{{JSBSim}}

[[Category:Aircraft enhancement|Fuel system JSBSim]]
[[Category:Howto|Fuel system JSBSim]]

OpenGL performance

2022-08-30T10:28:44Z

MariuszXC: /* NVIDIA GTX 1060 + Intel Core i5-2550K @ 3.4 GHz */

== OpenGL performance ==
{{See also|Profiling performance}}

OpenGL performance can be tested using glmark2 program. It is available in most Linux distributions. In Debian derived distributions (like Ubuntu) it can be installed by issuing ''sudo apt install glmark2'' from command line.

The data presented below was taken by running ''glmark2'' without any additional options, i.e. with default settings, on an otherwise idle system.

By comparing your results with measurements taken on other similar systems you can verify if your hardware and software combination is performing as expected.

=== Integrated graphics ===
==== Intel i5-4310M @ 2.70 GHz (integrated Intel HD 4600 GPU) ====

'''glmark2 Score: 1668'''

{{collapsible script
| type = details
| title = (click show to expand)
| lang = text
| script = ----
glmark2 2014.03+git20150611.fa71af2d
----
OpenGL Information
GL_VENDOR: Intel Open Source Technology Center
GL_RENDERER: Mesa DRI Intel(R) Haswell Mobile
GL_VERSION: 3.0 Mesa 18.0.5
----
<pre>
[build] use-vbo=false: FPS: 2256 FrameTime: 0.443 ms
[build] use-vbo=true: FPS: 2500 FrameTime: 0.400 ms
[texture] texture-filter=nearest: FPS: 2183 FrameTime: 0.458 ms
[texture] texture-filter=linear: FPS: 2180 FrameTime: 0.459 ms
[texture] texture-filter=mipmap: FPS: 2250 FrameTime: 0.444 ms
[shading] shading=gouraud: FPS: 2042 FrameTime: 0.490 ms
[shading] shading=blinn-phong-inf: FPS: 2049 FrameTime: 0.488 ms
[shading] shading=phong: FPS: 1938 FrameTime: 0.516 ms
[shading] shading=cel: FPS: 2037 FrameTime: 0.491 ms
[bump] bump-render=high-poly: FPS: 1701 FrameTime: 0.588 ms
[bump] bump-render=normals: FPS: 2419 FrameTime: 0.413 ms
[bump] bump-render=height: FPS: 2382 FrameTime: 0.420 ms
[effect2d] kernel=0,1,0;1,-4,1;0,1,0;: FPS: 1758 FrameTime: 0.569 ms
[effect2d] kernel=1,1,1,1,1;1,1,1,1,1;1,1,1,1,1;: FPS: 886 FrameTime: 1.129 ms
[pulsar] light=false:quads=5:texture=false: FPS: 2008 FrameTime: 0.498 ms
[desktop] blur-radius=5:effect=blur:passes=1:separable=true:windows=4: FPS: 749 FrameTime: 1.335 ms
[desktop] effect=shadow:windows=4: FPS: 1094 FrameTime: 0.914 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 770 FrameTime: 1.299 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=subdata: FPS: 655 FrameTime: 1.527 ms
[buffer] columns=200:interleave=true:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 857 FrameTime: 1.167 ms
[ideas] speed=duration: FPS: 1776 FrameTime: 0.563 ms
[jellyfish] <default>: FPS: 1275 FrameTime: 0.784 ms
[terrain] <default>: FPS: 173 FrameTime: 5.780 ms
[shadow] <default>: FPS: 805 FrameTime: 1.242 ms
[refract] <default>: FPS: 268 FrameTime: 3.731 ms
[conditionals] fragment-steps=0:vertex-steps=0: FPS: 2038 FrameTime: 0.491 ms
[conditionals] fragment-steps=5:vertex-steps=0: FPS: 2039 FrameTime: 0.490 ms
[conditionals] fragment-steps=0:vertex-steps=5: FPS: 2028 FrameTime: 0.493 ms
[function] fragment-complexity=low:fragment-steps=5: FPS: 2037 FrameTime: 0.491 ms
[function] fragment-complexity=medium:fragment-steps=5: FPS: 2051 FrameTime: 0.488 ms
[loop] fragment-loop=false:fragment-steps=5:vertex-steps=5: FPS: 1879 FrameTime: 0.532 ms
[loop] fragment-steps=5:fragment-uniform=false:vertex-steps=5: FPS: 1922 FrameTime: 0.520 ms
[loop] fragment-steps=5:fragment-uniform=true:vertex-steps=5: FPS: 2039 FrameTime: 0.490 ms</pre>
}}

==== Intel i5-6200U @ 2.3 GHz (integrated Intel UHD 620 GPU) ====
Remark: CPU clock boosted to 2.8 GHz during benchmarking

'''glmark2 Score: 1294'''

{{collapsible script
| type = details
| title = (click show to expand)
| lang = text
| script = ----
glmark2 2021.02
----
OpenGL Information
GL_VENDOR: Intel
GL_RENDERER: Mesa Intel(R) HD Graphics 520 (SKL GT2)
GL_VERSION: 4.6 (Compatibility Profile) Mesa 21.0.3
----
[build] use-vbo=false: FPS: 1500 FrameTime: 0.667 ms
[build] use-vbo=true: FPS: 1959 FrameTime: 0.510 ms
[texture] texture-filter=nearest: FPS: 1722 FrameTime: 0.581 ms
[texture] texture-filter=linear: FPS: 1736 FrameTime: 0.576 ms
[texture] texture-filter=mipmap: FPS: 1673 FrameTime: 0.598 ms
[shading] shading=gouraud: FPS: 1584 FrameTime: 0.631 ms
[shading] shading=blinn-phong-inf: FPS: 1554 FrameTime: 0.644 ms
[shading] shading=phong: FPS: 1559 FrameTime: 0.641 ms
[shading] shading=cel: FPS: 1571 FrameTime: 0.637 ms
[bump] bump-render=high-poly: FPS: 1123 FrameTime: 0.890 ms
[bump] bump-render=normals: FPS: 1945 FrameTime: 0.514 ms
[bump] bump-render=height: FPS: 1881 FrameTime: 0.532 ms
[effect2d] kernel=0,1,0;1,-4,1;0,1,0;: FPS: 1359 FrameTime: 0.736 ms
[effect2d] kernel=1,1,1,1,1;1,1,1,1,1;1,1,1,1,1;: FPS: 851 FrameTime: 1.175 ms
[pulsar] light=false:quads=5:texture=false: FPS: 1646 FrameTime: 0.608 ms
[desktop] blur-radius=5:effect=blur:passes=1:separable=true:windows=4: FPS: 757 FrameTime: 1.321 ms
[desktop] effect=shadow:windows=4: FPS: 1094 FrameTime: 0.914 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 585 FrameTime: 1.709 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=subdata: FPS: 529 FrameTime: 1.890 ms
[buffer] columns=200:interleave=true:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 669 FrameTime: 1.495 ms
[ideas] speed=duration: FPS: 1489 FrameTime: 0.672 ms
[jellyfish] <default>: FPS: 1236 FrameTime: 0.809 ms
[terrain] <default>: FPS: 188 FrameTime: 5.319 ms
[shadow] <default>: FPS: 1014 FrameTime: 0.986 ms
[refract] <default>: FPS: 356 FrameTime: 2.809 ms
[conditionals] fragment-steps=0:vertex-steps=0: FPS: 1360 FrameTime: 0.735 ms
[conditionals] fragment-steps=5:vertex-steps=0: FPS: 1407 FrameTime: 0.711 ms
[conditionals] fragment-steps=0:vertex-steps=5: FPS: 1393 FrameTime: 0.718 ms
[function] fragment-complexity=low:fragment-steps=5: FPS: 1412 FrameTime: 0.708 ms
[function] fragment-complexity=medium:fragment-steps=5: FPS: 1416 FrameTime: 0.706 ms
[loop] fragment-loop=false:fragment-steps=5:vertex-steps=5: FPS: 1369 FrameTime: 0.730 ms
[loop] fragment-steps=5:fragment-uniform=false:vertex-steps=5: FPS: 1388 FrameTime: 0.720 ms
[loop] fragment-steps=5:fragment-uniform=true:vertex-steps=5: FPS: 1383 FrameTime: 0.723 ms
}}

=== Discrete graphics card ===
Note: this section also contains hybrid configurations (e.g. laptops with dual GPU technology)

==== AMD FirePro M5950 + Intel i5-2520M ====
Remark: dual GPU technology laptop, no test details available.

'''glmark2 Score: 5600'''

==== NVIDIA RTX2060 6GB + AMD Ryzen 7 3700X 8-Core 4GHz ====
Note: one tests resulted in errors and finally a core dump.
Another test on the same hardware, with different drivers, completed.
Both test details are included.

'''glmark2 Score: 9537'''

{{collapsible script
| type = details
| title = (click show to expand)
| lang = text
| script =----
glmark2 2021.02
----
OpenGL Information
GL_VENDOR: NVIDIA Corporation
GL_RENDERER: NVIDIA GeForce RTX 2060/PCIe/SSE2
GL_VERSION: 4.6.0 NVIDIA 495.46
----
<pre>
[build] use-vbo=false: FPS: 13809 FrameTime: 0.072 ms
[build] use-vbo=true: FPS: 28367 FrameTime: 0.035 ms
[texture] texture-filter=nearest: FPS: 27958 FrameTime: 0.036 ms
[texture] texture-filter=linear: FPS: 28120 FrameTime: 0.036 ms
[texture] texture-filter=mipmap: FPS: 28036 FrameTime: 0.036 ms
[shading] shading=gouraud: FPS: 26428 FrameTime: 0.038 ms
[shading] shading=blinn-phong-inf: FPS: 26320 FrameTime: 0.038 ms
[shading] shading=phong: FPS: 25800 FrameTime: 0.039 ms
[shading] shading=cel: FPS: 25498 FrameTime: 0.039 ms
[bump] bump-render=high-poly: FPS: 20696 FrameTime: 0.048 ms
[bump] bump-render=normals: FPS: 29599 FrameTime: 0.034 ms
Error: Failed to add fragment shader from file None:
Error: 0(15) : error C0000: syntax error, unexpected identifier, expecting "::" at token "highp"
Error: 0(36) : warning C1503: undefined variable "TextureCoord"
Error: 0(37) : warning C1503: undefined variable "TextureCoord"
Error: 0(38) : warning C1503: undefined variable "TextureCoord"
Error:
[bump] bump-render=height: Set up failed
[effect2d] kernel=0,1,0;1,-4,1;0,1,0;: FPS: 22140 FrameTime: 0.045 ms
[effect2d] kernel=1,1,1,1,1;1,1,1,1,1;1,1,1,1,1;: FPS: 15018 FrameTime: 0.067 ms
[pulsar] light=false:quads=5:texture=false: FPS: 27482 FrameTime: 0.036 ms
[desktop] blur-radius=5:effect=blur:passes=1:separable=true:windows=4: FPS: 8226 FrameTime: 0.122 ms
[desktop] effect=shadow:windows=4: FPS: 10260 FrameTime: 0.097 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 1490 FrameTime: 0.671 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=subdata: FPS: 1613 FrameTime: 0.620 ms
[buffer] columns=200:interleave=true:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 2147 FrameTime: 0.466 ms
[ideas] speed=duration: FPS: 14164 FrameTime: 0.071 ms
[jellyfish] <default>: FPS: 20591 FrameTime: 0.049 ms
Error: Failed to add fragment shader from file None:
Error: 0(26) : warning C7022: unrecognized profile specifier "highp"
Error: 0(26) : error C0502: syntax error at token "highp"
Error:
Error: Failed to add fragment shader from file None:
Error: 0(75) : warning C7022: unrecognized profile specifier "highp"
Error: 0(75) : error C0502: syntax error at token "highp"
Error:
[terrain] <default>:Segmentation fault (core dumped)</pre>
}}

{{collapsible script
| type = details
| title = (click show to expand)
| lang = text
| script =----
glmark2 2021.02
----
OpenGL Information
GL_VENDOR: NVIDIA Corporation
GL_RENDERER: NVIDIA GeForce RTX 2060/PCIe/SSE2
GL_VERSION: 4.6.0 NVIDIA 515.65.01
----
<pre>
[build] use-vbo=false: FPS: 8231 FrameTime: 0.121 ms
[build] use-vbo=true: FPS: 11817 FrameTime: 0.085 ms
[texture] texture-filter=nearest: FPS: 11830 FrameTime: 0.085 ms
[texture] texture-filter=linear: FPS: 11822 FrameTime: 0.085 ms
[texture] texture-filter=mipmap: FPS: 11813 FrameTime: 0.085 ms
[shading] shading=gouraud: FPS: 11501 FrameTime: 0.087 ms
[shading] shading=blinn-phong-inf: FPS: 11429 FrameTime: 0.087 ms
[shading] shading=phong: FPS: 11334 FrameTime: 0.088 ms
[shading] shading=cel: FPS: 11262 FrameTime: 0.089 ms
[bump] bump-render=high-poly: FPS: 10097 FrameTime: 0.099 ms
[bump] bump-render=normals: FPS: 12168 FrameTime: 0.082 ms
[bump] bump-render=height: FPS: 12004 FrameTime: 0.083 ms
[effect2d] kernel=0,1,0;1,-4,1;0,1,0;: FPS: 10522 FrameTime: 0.095 ms
[effect2d] kernel=1,1,1,1,1;1,1,1,1,1;1,1,1,1,1;: FPS: 8468 FrameTime: 0.118 ms
[pulsar] light=false:quads=5:texture=false: FPS: 11776 FrameTime: 0.085 ms
[desktop] blur-radius=5:effect=blur:passes=1:separable=true:windows=4: FPS: 5667 FrameTime: 0.176 ms
[desktop] effect=shadow:windows=4: FPS: 8895 FrameTime: 0.112 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 1796 FrameTime: 0.557 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=subdata: FPS: 2017 FrameTime: 0.496 ms
[buffer] columns=200:interleave=true:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 2176 FrameTime: 0.460 ms
[ideas] speed=duration: FPS: 10641 FrameTime: 0.094 ms
[jellyfish] <default>: FPS: 10085 FrameTime: 0.099 ms
[terrain] <default>: FPS: 1323 FrameTime: 0.756 ms
[shadow] <default>: FPS: 9418 FrameTime: 0.106 ms
[refract] <default>: FPS: 4595 FrameTime: 0.218 ms
[conditionals] fragment-steps=0:vertex-steps=0: FPS: 11552 FrameTime: 0.087 ms
[conditionals] fragment-steps=5:vertex-steps=0: FPS: 11498 FrameTime: 0.087 ms
[conditionals] fragment-steps=0:vertex-steps=5: FPS: 11555 FrameTime: 0.087 ms
[function] fragment-complexity=low:fragment-steps=5: FPS: 11586 FrameTime: 0.086 ms
[function] fragment-complexity=medium:fragment-steps=5: FPS: 11454 FrameTime: 0.087 ms
[loop] fragment-loop=false:fragment-steps=5:vertex-steps=5: FPS: 11521 FrameTime: 0.087 ms
[loop] fragment-steps=5:fragment-uniform=false:vertex-steps=5: FPS: 11495 FrameTime: 0.087 ms
[loop] fragment-steps=5:fragment-uniform=true:vertex-steps=5: FPS: 11403 FrameTime: 0.088 ms</pre>
}}

==== AMD Tahiti XT [Radeon HD 7970 / R9 280X] + Intel Core i5-11600K @ 3.90GHz ====

'''glmark2 Score: 13781'''

{{collapsible script
| type = details
| title = (click show to expand)
| lang = text
| script = ----
glmark2 2021.02
----
OpenGL Information
GL_VENDOR: AMD
GL_RENDERER: AMD TAHITI (DRM 2.50.0, 5.11.0-44-generic, LLVM 12.0.0)
GL_VERSION: 4.5 (Compatibility Profile) Mesa 21.0.3
----
[build] use-vbo=false: FPS: 12290 FrameTime: 0.081 ms
[build] use-vbo=true: FPS: 19086 FrameTime: 0.052 ms
[texture] texture-filter=nearest: FPS: 18131 FrameTime: 0.055 ms
[texture] texture-filter=linear: FPS: 18165 FrameTime: 0.055 ms
[texture] texture-filter=mipmap: FPS: 18563 FrameTime: 0.054 ms
[shading] shading=gouraud: FPS: 16185 FrameTime: 0.062 ms
[shading] shading=blinn-phong-inf: FPS: 16135 FrameTime: 0.062 ms
[shading] shading=phong: FPS: 16042 FrameTime: 0.062 ms
[shading] shading=cel: FPS: 16036 FrameTime: 0.062 ms
[bump] bump-render=high-poly: FPS: 9338 FrameTime: 0.107 ms
[bump] bump-render=normals: FPS: 19774 FrameTime: 0.051 ms
[bump] bump-render=height: FPS: 19534 FrameTime: 0.051 ms
[effect2d] kernel=0,1,0;1,-4,1;0,1,0;: FPS: 15477 FrameTime: 0.065 ms
[effect2d] kernel=1,1,1,1,1;1,1,1,1,1;1,1,1,1,1;: FPS: 10139 FrameTime: 0.099 ms
[pulsar] light=false:quads=5:texture=false: FPS: 16858 FrameTime: 0.059 ms
[desktop] blur-radius=5:effect=blur:passes=1:separable=true:windows=4: FPS: 5961 FrameTime: 0.168 ms
[desktop] effect=shadow:windows=4: FPS: 9994 FrameTime: 0.100 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 2577 FrameTime: 0.388 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=subdata: FPS: 3585 FrameTime: 0.279 ms
[buffer] columns=200:interleave=true:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 3158 FrameTime: 0.317 ms
[ideas] speed=duration: FPS: 11924 FrameTime: 0.084 ms
[jellyfish] <default>: FPS: 12073 FrameTime: 0.083 ms
[terrain] <default>: FPS: 1350 FrameTime: 0.741 ms
[shadow] <default>: FPS: 9986 FrameTime: 0.100 ms
[refract] <default>: FPS: 2500 FrameTime: 0.400 ms
[conditionals] fragment-steps=0:vertex-steps=0: FPS: 18815 FrameTime: 0.053 ms
[conditionals] fragment-steps=5:vertex-steps=0: FPS: 18705 FrameTime: 0.053 ms
[conditionals] fragment-steps=0:vertex-steps=5: FPS: 18787 FrameTime: 0.053 ms
[function] fragment-complexity=low:fragment-steps=5: FPS: 18759 FrameTime: 0.053 ms
[function] fragment-complexity=medium:fragment-steps=5: FPS: 18691 FrameTime: 0.054 ms
[loop] fragment-loop=false:fragment-steps=5:vertex-steps=5: FPS: 18755 FrameTime: 0.053 ms
[loop] fragment-steps=5:fragment-uniform=false:vertex-steps=5: FPS: 18759 FrameTime: 0.053 ms
[loop] fragment-steps=5:fragment-uniform=true:vertex-steps=5: FPS: 18654 FrameTime: 0.054 ms
}}

==== NVIDIA GTX-1060 6GB + AMD R7 3700X @ 4.2 GHz, 8 cores, HT off ====

'''glmark2 Score: 20641'''

{{collapsible script
| type = details
| title = (click show to expand)
| lang = text
| script = ----
glmark2 2014.03+git20150611.fa71af2d
----
OpenGL Information
GL_VENDOR: NVIDIA Corporation
GL_RENDERER: GeForce GTX 1060 6GB/PCIe/SSE2
GL_VERSION: 4.6.0 NVIDIA 460.91.03
----
[build] use-vbo=false: FPS: 15192 FrameTime: 0.066 ms
[build] use-vbo=true: FPS: 30325 FrameTime: 0.033 ms
[texture] texture-filter=nearest: FPS: 27634 FrameTime: 0.036 ms
[texture] texture-filter=linear: FPS: 27511 FrameTime: 0.036 ms
[texture] texture-filter=mipmap: FPS: 28397 FrameTime: 0.035 ms
[shading] shading=gouraud: FPS: 26079 FrameTime: 0.038 ms
[shading] shading=blinn-phong-inf: FPS: 25796 FrameTime: 0.039 ms
[shading] shading=phong: FPS: 25060 FrameTime: 0.040 ms
[shading] shading=cel: FPS: 25321 FrameTime: 0.039 ms
[bump] bump-render=high-poly: FPS: 17451 FrameTime: 0.057 ms
[bump] bump-render=normals: FPS: 31963 FrameTime: 0.031 ms
[bump] bump-render=height: FPS: 31608 FrameTime: 0.032 ms
[effect2d] kernel=0,1,0;1,-4,1;0,1,0;: FPS: 20418 FrameTime: 0.049 ms
[effect2d] kernel=1,1,1,1,1;1,1,1,1,1;1,1,1,1,1;: FPS: 12585 FrameTime: 0.079 ms
[pulsar] light=false:quads=5:texture=false: FPS: 28174 FrameTime: 0.035 ms
[desktop] blur-radius=5:effect=blur:passes=1:separable=true:windows=4: FPS: 7331 FrameTime: 0.136 ms
[desktop] effect=shadow:windows=4: FPS: 14034 FrameTime: 0.071 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 2363 FrameTime: 0.423 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=subdata: FPS: 2783 FrameTime: 0.359 ms
[buffer] columns=200:interleave=true:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 2330 FrameTime: 0.429 ms
[ideas] speed=duration: FPS: 19421 FrameTime: 0.051 ms
[jellyfish] <default>: FPS: 17291 FrameTime: 0.058 ms
[terrain] <default>: FPS: 1349 FrameTime: 0.741 ms
[shadow] <default>: FPS: 15688 FrameTime: 0.064 ms
[refract] <default>: FPS: 4783 FrameTime: 0.209 ms
[conditionals] fragment-steps=0:vertex-steps=0: FPS: 28599 FrameTime: 0.035 ms
[conditionals] fragment-steps=5:vertex-steps=0: FPS: 27499 FrameTime: 0.036 ms
[conditionals] fragment-steps=0:vertex-steps=5: FPS: 28191 FrameTime: 0.035 ms
[function] fragment-complexity=low:fragment-steps=5: FPS: 27695 FrameTime: 0.036 ms
[function] fragment-complexity=medium:fragment-steps=5: FPS: 26605 FrameTime: 0.038 ms
[loop] fragment-loop=false:fragment-steps=5:vertex-steps=5: FPS: 27340 FrameTime: 0.037 ms
[loop] fragment-steps=5:fragment-uniform=false:vertex-steps=5: FPS: 27361 FrameTime: 0.037 ms
[loop] fragment-steps=5:fragment-uniform=true:vertex-steps=5: FPS: 26984 FrameTime: 0.037 ms
}}

==== NVIDIA Quadro K1000M 1GB + Intel Core i7-3610Q @ 2.3 GHz ====
Remark: during glmark2 testing CPU clock boosted to 3.3 GHz

''' glmark2 Score: 2754 '''

{{collapsible script
| type = details
| title = (click show to expand)
| lang = text
| script = ----
glmark2 2014.03+git20150611.fa71af2d
----
OpenGL Information
GL_VENDOR: NVIDIA Corporation
GL_RENDERER: Quadro K1000M/PCIe/SSE2
GL_VERSION: 4.6.0 NVIDIA 390.138
----
[build] use-vbo=false: FPS: 4154 FrameTime: 0.241 ms
[build] use-vbo=true: FPS: 4205 FrameTime: 0.238 ms
[texture] texture-filter=nearest: FPS: 3791 FrameTime: 0.264 ms
[texture] texture-filter=linear: FPS: 3718 FrameTime: 0.269 ms
[texture] texture-filter=mipmap: FPS: 3761 FrameTime: 0.266 ms
[shading] shading=gouraud: FPS: 3187 FrameTime: 0.314 ms
[shading] shading=blinn-phong-inf: FPS: 3200 FrameTime: 0.312 ms
[shading] shading=phong: FPS: 3078 FrameTime: 0.325 ms
[shading] shading=cel: FPS: 3065 FrameTime: 0.326 ms
[bump] bump-render=high-poly: FPS: 1674 FrameTime: 0.597 ms
[bump] bump-render=normals: FPS: 4329 FrameTime: 0.231 ms
[bump] bump-render=height: FPS: 4174 FrameTime: 0.240 ms
[effect2d] kernel=0,1,0;1,-4,1;0,1,0;: FPS: 2356 FrameTime: 0.424 ms
[effect2d] kernel=1,1,1,1,1;1,1,1,1,1;1,1,1,1,1;: FPS: 1249 FrameTime: 0.801 ms
[pulsar] light=false:quads=5:texture=false: FPS: 3550 FrameTime: 0.282 ms
[desktop] blur-radius=5:effect=blur:passes=1:separable=true:windows=4: FPS: 888 FrameTime: 1.126 ms
[desktop] effect=shadow:windows=4: FPS: 1453 FrameTime: 0.688 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 952 FrameTime: 1.050 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=subdata: FPS: 1277 FrameTime: 0.783 ms
[buffer] columns=200:interleave=true:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 977 FrameTime: 1.024 ms
[ideas] speed=duration: FPS: 2926 FrameTime: 0.342 ms
[jellyfish] <default>: FPS: 1551 FrameTime: 0.645 ms
[terrain] <default>: FPS: 173 FrameTime: 5.780 ms
[shadow] <default>: FPS: 2420 FrameTime: 0.413 ms
[refract] <default>: FPS: 431 FrameTime: 2.320 ms
[conditionals] fragment-steps=0:vertex-steps=0: FPS: 3776 FrameTime: 0.265 ms
[conditionals] fragment-steps=5:vertex-steps=0: FPS: 3061 FrameTime: 0.327 ms
[conditionals] fragment-steps=0:vertex-steps=5: FPS: 3776 FrameTime: 0.265 ms
[function] fragment-complexity=low:fragment-steps=5: FPS: 3775 FrameTime: 0.265 ms
[function] fragment-complexity=medium:fragment-steps=5: FPS: 3058 FrameTime: 0.327 ms
[loop] fragment-loop=false:fragment-steps=5:vertex-steps=5: FPS: 3776 FrameTime: 0.265 ms
[loop] fragment-steps=5:fragment-uniform=false:vertex-steps=5: FPS: 3776 FrameTime: 0.265 ms
[loop] fragment-steps=5:fragment-uniform=true:vertex-steps=5: FPS: 3375 FrameTime: 0.296 ms
}}

==== NVIDIA GTX 750 + Intel Core i5-2550K @ 3.4 GHz ====
Remark: no test details available.

'''glmark2 Score: 9000'''

==== NVIDIA GTX 1060 + Intel Core i5-2550K @ 3.4 GHz ====
Remark: no test details available.

'''glmark2 Score: 19000'''

OpenGL performance

2022-08-30T10:28:31Z

MariuszXC: /* NVIDIA GTX 750 + Intel Core i5-2550K @ 3.4 GHz */

== OpenGL performance ==
{{See also|Profiling performance}}

OpenGL performance can be tested using glmark2 program. It is available in most Linux distributions. In Debian derived distributions (like Ubuntu) it can be installed by issuing ''sudo apt install glmark2'' from command line.

The data presented below was taken by running ''glmark2'' without any additional options, i.e. with default settings, on an otherwise idle system.

By comparing your results with measurements taken on other similar systems you can verify if your hardware and software combination is performing as expected.

=== Integrated graphics ===
==== Intel i5-4310M @ 2.70 GHz (integrated Intel HD 4600 GPU) ====

'''glmark2 Score: 1668'''

{{collapsible script
| type = details
| title = (click show to expand)
| lang = text
| script = ----
glmark2 2014.03+git20150611.fa71af2d
----
OpenGL Information
GL_VENDOR: Intel Open Source Technology Center
GL_RENDERER: Mesa DRI Intel(R) Haswell Mobile
GL_VERSION: 3.0 Mesa 18.0.5
----
<pre>
[build] use-vbo=false: FPS: 2256 FrameTime: 0.443 ms
[build] use-vbo=true: FPS: 2500 FrameTime: 0.400 ms
[texture] texture-filter=nearest: FPS: 2183 FrameTime: 0.458 ms
[texture] texture-filter=linear: FPS: 2180 FrameTime: 0.459 ms
[texture] texture-filter=mipmap: FPS: 2250 FrameTime: 0.444 ms
[shading] shading=gouraud: FPS: 2042 FrameTime: 0.490 ms
[shading] shading=blinn-phong-inf: FPS: 2049 FrameTime: 0.488 ms
[shading] shading=phong: FPS: 1938 FrameTime: 0.516 ms
[shading] shading=cel: FPS: 2037 FrameTime: 0.491 ms
[bump] bump-render=high-poly: FPS: 1701 FrameTime: 0.588 ms
[bump] bump-render=normals: FPS: 2419 FrameTime: 0.413 ms
[bump] bump-render=height: FPS: 2382 FrameTime: 0.420 ms
[effect2d] kernel=0,1,0;1,-4,1;0,1,0;: FPS: 1758 FrameTime: 0.569 ms
[effect2d] kernel=1,1,1,1,1;1,1,1,1,1;1,1,1,1,1;: FPS: 886 FrameTime: 1.129 ms
[pulsar] light=false:quads=5:texture=false: FPS: 2008 FrameTime: 0.498 ms
[desktop] blur-radius=5:effect=blur:passes=1:separable=true:windows=4: FPS: 749 FrameTime: 1.335 ms
[desktop] effect=shadow:windows=4: FPS: 1094 FrameTime: 0.914 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 770 FrameTime: 1.299 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=subdata: FPS: 655 FrameTime: 1.527 ms
[buffer] columns=200:interleave=true:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 857 FrameTime: 1.167 ms
[ideas] speed=duration: FPS: 1776 FrameTime: 0.563 ms
[jellyfish] <default>: FPS: 1275 FrameTime: 0.784 ms
[terrain] <default>: FPS: 173 FrameTime: 5.780 ms
[shadow] <default>: FPS: 805 FrameTime: 1.242 ms
[refract] <default>: FPS: 268 FrameTime: 3.731 ms
[conditionals] fragment-steps=0:vertex-steps=0: FPS: 2038 FrameTime: 0.491 ms
[conditionals] fragment-steps=5:vertex-steps=0: FPS: 2039 FrameTime: 0.490 ms
[conditionals] fragment-steps=0:vertex-steps=5: FPS: 2028 FrameTime: 0.493 ms
[function] fragment-complexity=low:fragment-steps=5: FPS: 2037 FrameTime: 0.491 ms
[function] fragment-complexity=medium:fragment-steps=5: FPS: 2051 FrameTime: 0.488 ms
[loop] fragment-loop=false:fragment-steps=5:vertex-steps=5: FPS: 1879 FrameTime: 0.532 ms
[loop] fragment-steps=5:fragment-uniform=false:vertex-steps=5: FPS: 1922 FrameTime: 0.520 ms
[loop] fragment-steps=5:fragment-uniform=true:vertex-steps=5: FPS: 2039 FrameTime: 0.490 ms</pre>
}}

==== Intel i5-6200U @ 2.3 GHz (integrated Intel UHD 620 GPU) ====
Remark: CPU clock boosted to 2.8 GHz during benchmarking

'''glmark2 Score: 1294'''

{{collapsible script
| type = details
| title = (click show to expand)
| lang = text
| script = ----
glmark2 2021.02
----
OpenGL Information
GL_VENDOR: Intel
GL_RENDERER: Mesa Intel(R) HD Graphics 520 (SKL GT2)
GL_VERSION: 4.6 (Compatibility Profile) Mesa 21.0.3
----
[build] use-vbo=false: FPS: 1500 FrameTime: 0.667 ms
[build] use-vbo=true: FPS: 1959 FrameTime: 0.510 ms
[texture] texture-filter=nearest: FPS: 1722 FrameTime: 0.581 ms
[texture] texture-filter=linear: FPS: 1736 FrameTime: 0.576 ms
[texture] texture-filter=mipmap: FPS: 1673 FrameTime: 0.598 ms
[shading] shading=gouraud: FPS: 1584 FrameTime: 0.631 ms
[shading] shading=blinn-phong-inf: FPS: 1554 FrameTime: 0.644 ms
[shading] shading=phong: FPS: 1559 FrameTime: 0.641 ms
[shading] shading=cel: FPS: 1571 FrameTime: 0.637 ms
[bump] bump-render=high-poly: FPS: 1123 FrameTime: 0.890 ms
[bump] bump-render=normals: FPS: 1945 FrameTime: 0.514 ms
[bump] bump-render=height: FPS: 1881 FrameTime: 0.532 ms
[effect2d] kernel=0,1,0;1,-4,1;0,1,0;: FPS: 1359 FrameTime: 0.736 ms
[effect2d] kernel=1,1,1,1,1;1,1,1,1,1;1,1,1,1,1;: FPS: 851 FrameTime: 1.175 ms
[pulsar] light=false:quads=5:texture=false: FPS: 1646 FrameTime: 0.608 ms
[desktop] blur-radius=5:effect=blur:passes=1:separable=true:windows=4: FPS: 757 FrameTime: 1.321 ms
[desktop] effect=shadow:windows=4: FPS: 1094 FrameTime: 0.914 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 585 FrameTime: 1.709 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=subdata: FPS: 529 FrameTime: 1.890 ms
[buffer] columns=200:interleave=true:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 669 FrameTime: 1.495 ms
[ideas] speed=duration: FPS: 1489 FrameTime: 0.672 ms
[jellyfish] <default>: FPS: 1236 FrameTime: 0.809 ms
[terrain] <default>: FPS: 188 FrameTime: 5.319 ms
[shadow] <default>: FPS: 1014 FrameTime: 0.986 ms
[refract] <default>: FPS: 356 FrameTime: 2.809 ms
[conditionals] fragment-steps=0:vertex-steps=0: FPS: 1360 FrameTime: 0.735 ms
[conditionals] fragment-steps=5:vertex-steps=0: FPS: 1407 FrameTime: 0.711 ms
[conditionals] fragment-steps=0:vertex-steps=5: FPS: 1393 FrameTime: 0.718 ms
[function] fragment-complexity=low:fragment-steps=5: FPS: 1412 FrameTime: 0.708 ms
[function] fragment-complexity=medium:fragment-steps=5: FPS: 1416 FrameTime: 0.706 ms
[loop] fragment-loop=false:fragment-steps=5:vertex-steps=5: FPS: 1369 FrameTime: 0.730 ms
[loop] fragment-steps=5:fragment-uniform=false:vertex-steps=5: FPS: 1388 FrameTime: 0.720 ms
[loop] fragment-steps=5:fragment-uniform=true:vertex-steps=5: FPS: 1383 FrameTime: 0.723 ms
}}

=== Discrete graphics card ===
Note: this section also contains hybrid configurations (e.g. laptops with dual GPU technology)

==== AMD FirePro M5950 + Intel i5-2520M ====
Remark: dual GPU technology laptop, no test details available.

'''glmark2 Score: 5600'''

==== NVIDIA RTX2060 6GB + AMD Ryzen 7 3700X 8-Core 4GHz ====
Note: one tests resulted in errors and finally a core dump.
Another test on the same hardware, with different drivers, completed.
Both test details are included.

'''glmark2 Score: 9537'''

{{collapsible script
| type = details
| title = (click show to expand)
| lang = text
| script =----
glmark2 2021.02
----
OpenGL Information
GL_VENDOR: NVIDIA Corporation
GL_RENDERER: NVIDIA GeForce RTX 2060/PCIe/SSE2
GL_VERSION: 4.6.0 NVIDIA 495.46
----
<pre>
[build] use-vbo=false: FPS: 13809 FrameTime: 0.072 ms
[build] use-vbo=true: FPS: 28367 FrameTime: 0.035 ms
[texture] texture-filter=nearest: FPS: 27958 FrameTime: 0.036 ms
[texture] texture-filter=linear: FPS: 28120 FrameTime: 0.036 ms
[texture] texture-filter=mipmap: FPS: 28036 FrameTime: 0.036 ms
[shading] shading=gouraud: FPS: 26428 FrameTime: 0.038 ms
[shading] shading=blinn-phong-inf: FPS: 26320 FrameTime: 0.038 ms
[shading] shading=phong: FPS: 25800 FrameTime: 0.039 ms
[shading] shading=cel: FPS: 25498 FrameTime: 0.039 ms
[bump] bump-render=high-poly: FPS: 20696 FrameTime: 0.048 ms
[bump] bump-render=normals: FPS: 29599 FrameTime: 0.034 ms
Error: Failed to add fragment shader from file None:
Error: 0(15) : error C0000: syntax error, unexpected identifier, expecting "::" at token "highp"
Error: 0(36) : warning C1503: undefined variable "TextureCoord"
Error: 0(37) : warning C1503: undefined variable "TextureCoord"
Error: 0(38) : warning C1503: undefined variable "TextureCoord"
Error:
[bump] bump-render=height: Set up failed
[effect2d] kernel=0,1,0;1,-4,1;0,1,0;: FPS: 22140 FrameTime: 0.045 ms
[effect2d] kernel=1,1,1,1,1;1,1,1,1,1;1,1,1,1,1;: FPS: 15018 FrameTime: 0.067 ms
[pulsar] light=false:quads=5:texture=false: FPS: 27482 FrameTime: 0.036 ms
[desktop] blur-radius=5:effect=blur:passes=1:separable=true:windows=4: FPS: 8226 FrameTime: 0.122 ms
[desktop] effect=shadow:windows=4: FPS: 10260 FrameTime: 0.097 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 1490 FrameTime: 0.671 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=subdata: FPS: 1613 FrameTime: 0.620 ms
[buffer] columns=200:interleave=true:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 2147 FrameTime: 0.466 ms
[ideas] speed=duration: FPS: 14164 FrameTime: 0.071 ms
[jellyfish] <default>: FPS: 20591 FrameTime: 0.049 ms
Error: Failed to add fragment shader from file None:
Error: 0(26) : warning C7022: unrecognized profile specifier "highp"
Error: 0(26) : error C0502: syntax error at token "highp"
Error:
Error: Failed to add fragment shader from file None:
Error: 0(75) : warning C7022: unrecognized profile specifier "highp"
Error: 0(75) : error C0502: syntax error at token "highp"
Error:
[terrain] <default>:Segmentation fault (core dumped)</pre>
}}

{{collapsible script
| type = details
| title = (click show to expand)
| lang = text
| script =----
glmark2 2021.02
----
OpenGL Information
GL_VENDOR: NVIDIA Corporation
GL_RENDERER: NVIDIA GeForce RTX 2060/PCIe/SSE2
GL_VERSION: 4.6.0 NVIDIA 515.65.01
----
<pre>
[build] use-vbo=false: FPS: 8231 FrameTime: 0.121 ms
[build] use-vbo=true: FPS: 11817 FrameTime: 0.085 ms
[texture] texture-filter=nearest: FPS: 11830 FrameTime: 0.085 ms
[texture] texture-filter=linear: FPS: 11822 FrameTime: 0.085 ms
[texture] texture-filter=mipmap: FPS: 11813 FrameTime: 0.085 ms
[shading] shading=gouraud: FPS: 11501 FrameTime: 0.087 ms
[shading] shading=blinn-phong-inf: FPS: 11429 FrameTime: 0.087 ms
[shading] shading=phong: FPS: 11334 FrameTime: 0.088 ms
[shading] shading=cel: FPS: 11262 FrameTime: 0.089 ms
[bump] bump-render=high-poly: FPS: 10097 FrameTime: 0.099 ms
[bump] bump-render=normals: FPS: 12168 FrameTime: 0.082 ms
[bump] bump-render=height: FPS: 12004 FrameTime: 0.083 ms
[effect2d] kernel=0,1,0;1,-4,1;0,1,0;: FPS: 10522 FrameTime: 0.095 ms
[effect2d] kernel=1,1,1,1,1;1,1,1,1,1;1,1,1,1,1;: FPS: 8468 FrameTime: 0.118 ms
[pulsar] light=false:quads=5:texture=false: FPS: 11776 FrameTime: 0.085 ms
[desktop] blur-radius=5:effect=blur:passes=1:separable=true:windows=4: FPS: 5667 FrameTime: 0.176 ms
[desktop] effect=shadow:windows=4: FPS: 8895 FrameTime: 0.112 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 1796 FrameTime: 0.557 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=subdata: FPS: 2017 FrameTime: 0.496 ms
[buffer] columns=200:interleave=true:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 2176 FrameTime: 0.460 ms
[ideas] speed=duration: FPS: 10641 FrameTime: 0.094 ms
[jellyfish] <default>: FPS: 10085 FrameTime: 0.099 ms
[terrain] <default>: FPS: 1323 FrameTime: 0.756 ms
[shadow] <default>: FPS: 9418 FrameTime: 0.106 ms
[refract] <default>: FPS: 4595 FrameTime: 0.218 ms
[conditionals] fragment-steps=0:vertex-steps=0: FPS: 11552 FrameTime: 0.087 ms
[conditionals] fragment-steps=5:vertex-steps=0: FPS: 11498 FrameTime: 0.087 ms
[conditionals] fragment-steps=0:vertex-steps=5: FPS: 11555 FrameTime: 0.087 ms
[function] fragment-complexity=low:fragment-steps=5: FPS: 11586 FrameTime: 0.086 ms
[function] fragment-complexity=medium:fragment-steps=5: FPS: 11454 FrameTime: 0.087 ms
[loop] fragment-loop=false:fragment-steps=5:vertex-steps=5: FPS: 11521 FrameTime: 0.087 ms
[loop] fragment-steps=5:fragment-uniform=false:vertex-steps=5: FPS: 11495 FrameTime: 0.087 ms
[loop] fragment-steps=5:fragment-uniform=true:vertex-steps=5: FPS: 11403 FrameTime: 0.088 ms</pre>
}}

==== AMD Tahiti XT [Radeon HD 7970 / R9 280X] + Intel Core i5-11600K @ 3.90GHz ====

'''glmark2 Score: 13781'''

{{collapsible script
| type = details
| title = (click show to expand)
| lang = text
| script = ----
glmark2 2021.02
----
OpenGL Information
GL_VENDOR: AMD
GL_RENDERER: AMD TAHITI (DRM 2.50.0, 5.11.0-44-generic, LLVM 12.0.0)
GL_VERSION: 4.5 (Compatibility Profile) Mesa 21.0.3
----
[build] use-vbo=false: FPS: 12290 FrameTime: 0.081 ms
[build] use-vbo=true: FPS: 19086 FrameTime: 0.052 ms
[texture] texture-filter=nearest: FPS: 18131 FrameTime: 0.055 ms
[texture] texture-filter=linear: FPS: 18165 FrameTime: 0.055 ms
[texture] texture-filter=mipmap: FPS: 18563 FrameTime: 0.054 ms
[shading] shading=gouraud: FPS: 16185 FrameTime: 0.062 ms
[shading] shading=blinn-phong-inf: FPS: 16135 FrameTime: 0.062 ms
[shading] shading=phong: FPS: 16042 FrameTime: 0.062 ms
[shading] shading=cel: FPS: 16036 FrameTime: 0.062 ms
[bump] bump-render=high-poly: FPS: 9338 FrameTime: 0.107 ms
[bump] bump-render=normals: FPS: 19774 FrameTime: 0.051 ms
[bump] bump-render=height: FPS: 19534 FrameTime: 0.051 ms
[effect2d] kernel=0,1,0;1,-4,1;0,1,0;: FPS: 15477 FrameTime: 0.065 ms
[effect2d] kernel=1,1,1,1,1;1,1,1,1,1;1,1,1,1,1;: FPS: 10139 FrameTime: 0.099 ms
[pulsar] light=false:quads=5:texture=false: FPS: 16858 FrameTime: 0.059 ms
[desktop] blur-radius=5:effect=blur:passes=1:separable=true:windows=4: FPS: 5961 FrameTime: 0.168 ms
[desktop] effect=shadow:windows=4: FPS: 9994 FrameTime: 0.100 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 2577 FrameTime: 0.388 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=subdata: FPS: 3585 FrameTime: 0.279 ms
[buffer] columns=200:interleave=true:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 3158 FrameTime: 0.317 ms
[ideas] speed=duration: FPS: 11924 FrameTime: 0.084 ms
[jellyfish] <default>: FPS: 12073 FrameTime: 0.083 ms
[terrain] <default>: FPS: 1350 FrameTime: 0.741 ms
[shadow] <default>: FPS: 9986 FrameTime: 0.100 ms
[refract] <default>: FPS: 2500 FrameTime: 0.400 ms
[conditionals] fragment-steps=0:vertex-steps=0: FPS: 18815 FrameTime: 0.053 ms
[conditionals] fragment-steps=5:vertex-steps=0: FPS: 18705 FrameTime: 0.053 ms
[conditionals] fragment-steps=0:vertex-steps=5: FPS: 18787 FrameTime: 0.053 ms
[function] fragment-complexity=low:fragment-steps=5: FPS: 18759 FrameTime: 0.053 ms
[function] fragment-complexity=medium:fragment-steps=5: FPS: 18691 FrameTime: 0.054 ms
[loop] fragment-loop=false:fragment-steps=5:vertex-steps=5: FPS: 18755 FrameTime: 0.053 ms
[loop] fragment-steps=5:fragment-uniform=false:vertex-steps=5: FPS: 18759 FrameTime: 0.053 ms
[loop] fragment-steps=5:fragment-uniform=true:vertex-steps=5: FPS: 18654 FrameTime: 0.054 ms
}}

==== NVIDIA GTX-1060 6GB + AMD R7 3700X @ 4.2 GHz, 8 cores, HT off ====

'''glmark2 Score: 20641'''

{{collapsible script
| type = details
| title = (click show to expand)
| lang = text
| script = ----
glmark2 2014.03+git20150611.fa71af2d
----
OpenGL Information
GL_VENDOR: NVIDIA Corporation
GL_RENDERER: GeForce GTX 1060 6GB/PCIe/SSE2
GL_VERSION: 4.6.0 NVIDIA 460.91.03
----
[build] use-vbo=false: FPS: 15192 FrameTime: 0.066 ms
[build] use-vbo=true: FPS: 30325 FrameTime: 0.033 ms
[texture] texture-filter=nearest: FPS: 27634 FrameTime: 0.036 ms
[texture] texture-filter=linear: FPS: 27511 FrameTime: 0.036 ms
[texture] texture-filter=mipmap: FPS: 28397 FrameTime: 0.035 ms
[shading] shading=gouraud: FPS: 26079 FrameTime: 0.038 ms
[shading] shading=blinn-phong-inf: FPS: 25796 FrameTime: 0.039 ms
[shading] shading=phong: FPS: 25060 FrameTime: 0.040 ms
[shading] shading=cel: FPS: 25321 FrameTime: 0.039 ms
[bump] bump-render=high-poly: FPS: 17451 FrameTime: 0.057 ms
[bump] bump-render=normals: FPS: 31963 FrameTime: 0.031 ms
[bump] bump-render=height: FPS: 31608 FrameTime: 0.032 ms
[effect2d] kernel=0,1,0;1,-4,1;0,1,0;: FPS: 20418 FrameTime: 0.049 ms
[effect2d] kernel=1,1,1,1,1;1,1,1,1,1;1,1,1,1,1;: FPS: 12585 FrameTime: 0.079 ms
[pulsar] light=false:quads=5:texture=false: FPS: 28174 FrameTime: 0.035 ms
[desktop] blur-radius=5:effect=blur:passes=1:separable=true:windows=4: FPS: 7331 FrameTime: 0.136 ms
[desktop] effect=shadow:windows=4: FPS: 14034 FrameTime: 0.071 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 2363 FrameTime: 0.423 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=subdata: FPS: 2783 FrameTime: 0.359 ms
[buffer] columns=200:interleave=true:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 2330 FrameTime: 0.429 ms
[ideas] speed=duration: FPS: 19421 FrameTime: 0.051 ms
[jellyfish] <default>: FPS: 17291 FrameTime: 0.058 ms
[terrain] <default>: FPS: 1349 FrameTime: 0.741 ms
[shadow] <default>: FPS: 15688 FrameTime: 0.064 ms
[refract] <default>: FPS: 4783 FrameTime: 0.209 ms
[conditionals] fragment-steps=0:vertex-steps=0: FPS: 28599 FrameTime: 0.035 ms
[conditionals] fragment-steps=5:vertex-steps=0: FPS: 27499 FrameTime: 0.036 ms
[conditionals] fragment-steps=0:vertex-steps=5: FPS: 28191 FrameTime: 0.035 ms
[function] fragment-complexity=low:fragment-steps=5: FPS: 27695 FrameTime: 0.036 ms
[function] fragment-complexity=medium:fragment-steps=5: FPS: 26605 FrameTime: 0.038 ms
[loop] fragment-loop=false:fragment-steps=5:vertex-steps=5: FPS: 27340 FrameTime: 0.037 ms
[loop] fragment-steps=5:fragment-uniform=false:vertex-steps=5: FPS: 27361 FrameTime: 0.037 ms
[loop] fragment-steps=5:fragment-uniform=true:vertex-steps=5: FPS: 26984 FrameTime: 0.037 ms
}}

==== NVIDIA Quadro K1000M 1GB + Intel Core i7-3610Q @ 2.3 GHz ====
Remark: during glmark2 testing CPU clock boosted to 3.3 GHz

''' glmark2 Score: 2754 '''

{{collapsible script
| type = details
| title = (click show to expand)
| lang = text
| script = ----
glmark2 2014.03+git20150611.fa71af2d
----
OpenGL Information
GL_VENDOR: NVIDIA Corporation
GL_RENDERER: Quadro K1000M/PCIe/SSE2
GL_VERSION: 4.6.0 NVIDIA 390.138
----
[build] use-vbo=false: FPS: 4154 FrameTime: 0.241 ms
[build] use-vbo=true: FPS: 4205 FrameTime: 0.238 ms
[texture] texture-filter=nearest: FPS: 3791 FrameTime: 0.264 ms
[texture] texture-filter=linear: FPS: 3718 FrameTime: 0.269 ms
[texture] texture-filter=mipmap: FPS: 3761 FrameTime: 0.266 ms
[shading] shading=gouraud: FPS: 3187 FrameTime: 0.314 ms
[shading] shading=blinn-phong-inf: FPS: 3200 FrameTime: 0.312 ms
[shading] shading=phong: FPS: 3078 FrameTime: 0.325 ms
[shading] shading=cel: FPS: 3065 FrameTime: 0.326 ms
[bump] bump-render=high-poly: FPS: 1674 FrameTime: 0.597 ms
[bump] bump-render=normals: FPS: 4329 FrameTime: 0.231 ms
[bump] bump-render=height: FPS: 4174 FrameTime: 0.240 ms
[effect2d] kernel=0,1,0;1,-4,1;0,1,0;: FPS: 2356 FrameTime: 0.424 ms
[effect2d] kernel=1,1,1,1,1;1,1,1,1,1;1,1,1,1,1;: FPS: 1249 FrameTime: 0.801 ms
[pulsar] light=false:quads=5:texture=false: FPS: 3550 FrameTime: 0.282 ms
[desktop] blur-radius=5:effect=blur:passes=1:separable=true:windows=4: FPS: 888 FrameTime: 1.126 ms
[desktop] effect=shadow:windows=4: FPS: 1453 FrameTime: 0.688 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 952 FrameTime: 1.050 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=subdata: FPS: 1277 FrameTime: 0.783 ms
[buffer] columns=200:interleave=true:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 977 FrameTime: 1.024 ms
[ideas] speed=duration: FPS: 2926 FrameTime: 0.342 ms
[jellyfish] <default>: FPS: 1551 FrameTime: 0.645 ms
[terrain] <default>: FPS: 173 FrameTime: 5.780 ms
[shadow] <default>: FPS: 2420 FrameTime: 0.413 ms
[refract] <default>: FPS: 431 FrameTime: 2.320 ms
[conditionals] fragment-steps=0:vertex-steps=0: FPS: 3776 FrameTime: 0.265 ms
[conditionals] fragment-steps=5:vertex-steps=0: FPS: 3061 FrameTime: 0.327 ms
[conditionals] fragment-steps=0:vertex-steps=5: FPS: 3776 FrameTime: 0.265 ms
[function] fragment-complexity=low:fragment-steps=5: FPS: 3775 FrameTime: 0.265 ms
[function] fragment-complexity=medium:fragment-steps=5: FPS: 3058 FrameTime: 0.327 ms
[loop] fragment-loop=false:fragment-steps=5:vertex-steps=5: FPS: 3776 FrameTime: 0.265 ms
[loop] fragment-steps=5:fragment-uniform=false:vertex-steps=5: FPS: 3776 FrameTime: 0.265 ms
[loop] fragment-steps=5:fragment-uniform=true:vertex-steps=5: FPS: 3375 FrameTime: 0.296 ms
}}

==== NVIDIA GTX 750 + Intel Core i5-2550K @ 3.4 GHz ====
Remark: no test details available.

'''glmark2 Score: 9000'''

==== NVIDIA GTX 1060 + Intel Core i5-2550K @ 3.4 GHz ====
Remark: no test details available.

'''glmark2 Score: 19000'''

OpenGL performance

2022-08-30T10:28:18Z

MariuszXC: /* NVIDIA Quadro K1000M 1GB + Intel Core i7-3610Q @ 2.3 GHz */

== OpenGL performance ==
{{See also|Profiling performance}}

OpenGL performance can be tested using glmark2 program. It is available in most Linux distributions. In Debian derived distributions (like Ubuntu) it can be installed by issuing ''sudo apt install glmark2'' from command line.

The data presented below was taken by running ''glmark2'' without any additional options, i.e. with default settings, on an otherwise idle system.

By comparing your results with measurements taken on other similar systems you can verify if your hardware and software combination is performing as expected.

=== Integrated graphics ===
==== Intel i5-4310M @ 2.70 GHz (integrated Intel HD 4600 GPU) ====

'''glmark2 Score: 1668'''

{{collapsible script
| type = details
| title = (click show to expand)
| lang = text
| script = ----
glmark2 2014.03+git20150611.fa71af2d
----
OpenGL Information
GL_VENDOR: Intel Open Source Technology Center
GL_RENDERER: Mesa DRI Intel(R) Haswell Mobile
GL_VERSION: 3.0 Mesa 18.0.5
----
<pre>
[build] use-vbo=false: FPS: 2256 FrameTime: 0.443 ms
[build] use-vbo=true: FPS: 2500 FrameTime: 0.400 ms
[texture] texture-filter=nearest: FPS: 2183 FrameTime: 0.458 ms
[texture] texture-filter=linear: FPS: 2180 FrameTime: 0.459 ms
[texture] texture-filter=mipmap: FPS: 2250 FrameTime: 0.444 ms
[shading] shading=gouraud: FPS: 2042 FrameTime: 0.490 ms
[shading] shading=blinn-phong-inf: FPS: 2049 FrameTime: 0.488 ms
[shading] shading=phong: FPS: 1938 FrameTime: 0.516 ms
[shading] shading=cel: FPS: 2037 FrameTime: 0.491 ms
[bump] bump-render=high-poly: FPS: 1701 FrameTime: 0.588 ms
[bump] bump-render=normals: FPS: 2419 FrameTime: 0.413 ms
[bump] bump-render=height: FPS: 2382 FrameTime: 0.420 ms
[effect2d] kernel=0,1,0;1,-4,1;0,1,0;: FPS: 1758 FrameTime: 0.569 ms
[effect2d] kernel=1,1,1,1,1;1,1,1,1,1;1,1,1,1,1;: FPS: 886 FrameTime: 1.129 ms
[pulsar] light=false:quads=5:texture=false: FPS: 2008 FrameTime: 0.498 ms
[desktop] blur-radius=5:effect=blur:passes=1:separable=true:windows=4: FPS: 749 FrameTime: 1.335 ms
[desktop] effect=shadow:windows=4: FPS: 1094 FrameTime: 0.914 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 770 FrameTime: 1.299 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=subdata: FPS: 655 FrameTime: 1.527 ms
[buffer] columns=200:interleave=true:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 857 FrameTime: 1.167 ms
[ideas] speed=duration: FPS: 1776 FrameTime: 0.563 ms
[jellyfish] <default>: FPS: 1275 FrameTime: 0.784 ms
[terrain] <default>: FPS: 173 FrameTime: 5.780 ms
[shadow] <default>: FPS: 805 FrameTime: 1.242 ms
[refract] <default>: FPS: 268 FrameTime: 3.731 ms
[conditionals] fragment-steps=0:vertex-steps=0: FPS: 2038 FrameTime: 0.491 ms
[conditionals] fragment-steps=5:vertex-steps=0: FPS: 2039 FrameTime: 0.490 ms
[conditionals] fragment-steps=0:vertex-steps=5: FPS: 2028 FrameTime: 0.493 ms
[function] fragment-complexity=low:fragment-steps=5: FPS: 2037 FrameTime: 0.491 ms
[function] fragment-complexity=medium:fragment-steps=5: FPS: 2051 FrameTime: 0.488 ms
[loop] fragment-loop=false:fragment-steps=5:vertex-steps=5: FPS: 1879 FrameTime: 0.532 ms
[loop] fragment-steps=5:fragment-uniform=false:vertex-steps=5: FPS: 1922 FrameTime: 0.520 ms
[loop] fragment-steps=5:fragment-uniform=true:vertex-steps=5: FPS: 2039 FrameTime: 0.490 ms</pre>
}}

==== Intel i5-6200U @ 2.3 GHz (integrated Intel UHD 620 GPU) ====
Remark: CPU clock boosted to 2.8 GHz during benchmarking

'''glmark2 Score: 1294'''

{{collapsible script
| type = details
| title = (click show to expand)
| lang = text
| script = ----
glmark2 2021.02
----
OpenGL Information
GL_VENDOR: Intel
GL_RENDERER: Mesa Intel(R) HD Graphics 520 (SKL GT2)
GL_VERSION: 4.6 (Compatibility Profile) Mesa 21.0.3
----
[build] use-vbo=false: FPS: 1500 FrameTime: 0.667 ms
[build] use-vbo=true: FPS: 1959 FrameTime: 0.510 ms
[texture] texture-filter=nearest: FPS: 1722 FrameTime: 0.581 ms
[texture] texture-filter=linear: FPS: 1736 FrameTime: 0.576 ms
[texture] texture-filter=mipmap: FPS: 1673 FrameTime: 0.598 ms
[shading] shading=gouraud: FPS: 1584 FrameTime: 0.631 ms
[shading] shading=blinn-phong-inf: FPS: 1554 FrameTime: 0.644 ms
[shading] shading=phong: FPS: 1559 FrameTime: 0.641 ms
[shading] shading=cel: FPS: 1571 FrameTime: 0.637 ms
[bump] bump-render=high-poly: FPS: 1123 FrameTime: 0.890 ms
[bump] bump-render=normals: FPS: 1945 FrameTime: 0.514 ms
[bump] bump-render=height: FPS: 1881 FrameTime: 0.532 ms
[effect2d] kernel=0,1,0;1,-4,1;0,1,0;: FPS: 1359 FrameTime: 0.736 ms
[effect2d] kernel=1,1,1,1,1;1,1,1,1,1;1,1,1,1,1;: FPS: 851 FrameTime: 1.175 ms
[pulsar] light=false:quads=5:texture=false: FPS: 1646 FrameTime: 0.608 ms
[desktop] blur-radius=5:effect=blur:passes=1:separable=true:windows=4: FPS: 757 FrameTime: 1.321 ms
[desktop] effect=shadow:windows=4: FPS: 1094 FrameTime: 0.914 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 585 FrameTime: 1.709 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=subdata: FPS: 529 FrameTime: 1.890 ms
[buffer] columns=200:interleave=true:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 669 FrameTime: 1.495 ms
[ideas] speed=duration: FPS: 1489 FrameTime: 0.672 ms
[jellyfish] <default>: FPS: 1236 FrameTime: 0.809 ms
[terrain] <default>: FPS: 188 FrameTime: 5.319 ms
[shadow] <default>: FPS: 1014 FrameTime: 0.986 ms
[refract] <default>: FPS: 356 FrameTime: 2.809 ms
[conditionals] fragment-steps=0:vertex-steps=0: FPS: 1360 FrameTime: 0.735 ms
[conditionals] fragment-steps=5:vertex-steps=0: FPS: 1407 FrameTime: 0.711 ms
[conditionals] fragment-steps=0:vertex-steps=5: FPS: 1393 FrameTime: 0.718 ms
[function] fragment-complexity=low:fragment-steps=5: FPS: 1412 FrameTime: 0.708 ms
[function] fragment-complexity=medium:fragment-steps=5: FPS: 1416 FrameTime: 0.706 ms
[loop] fragment-loop=false:fragment-steps=5:vertex-steps=5: FPS: 1369 FrameTime: 0.730 ms
[loop] fragment-steps=5:fragment-uniform=false:vertex-steps=5: FPS: 1388 FrameTime: 0.720 ms
[loop] fragment-steps=5:fragment-uniform=true:vertex-steps=5: FPS: 1383 FrameTime: 0.723 ms
}}

=== Discrete graphics card ===
Note: this section also contains hybrid configurations (e.g. laptops with dual GPU technology)

==== AMD FirePro M5950 + Intel i5-2520M ====
Remark: dual GPU technology laptop, no test details available.

'''glmark2 Score: 5600'''

==== NVIDIA RTX2060 6GB + AMD Ryzen 7 3700X 8-Core 4GHz ====
Note: one tests resulted in errors and finally a core dump.
Another test on the same hardware, with different drivers, completed.
Both test details are included.

'''glmark2 Score: 9537'''

{{collapsible script
| type = details
| title = (click show to expand)
| lang = text
| script =----
glmark2 2021.02
----
OpenGL Information
GL_VENDOR: NVIDIA Corporation
GL_RENDERER: NVIDIA GeForce RTX 2060/PCIe/SSE2
GL_VERSION: 4.6.0 NVIDIA 495.46
----
<pre>
[build] use-vbo=false: FPS: 13809 FrameTime: 0.072 ms
[build] use-vbo=true: FPS: 28367 FrameTime: 0.035 ms
[texture] texture-filter=nearest: FPS: 27958 FrameTime: 0.036 ms
[texture] texture-filter=linear: FPS: 28120 FrameTime: 0.036 ms
[texture] texture-filter=mipmap: FPS: 28036 FrameTime: 0.036 ms
[shading] shading=gouraud: FPS: 26428 FrameTime: 0.038 ms
[shading] shading=blinn-phong-inf: FPS: 26320 FrameTime: 0.038 ms
[shading] shading=phong: FPS: 25800 FrameTime: 0.039 ms
[shading] shading=cel: FPS: 25498 FrameTime: 0.039 ms
[bump] bump-render=high-poly: FPS: 20696 FrameTime: 0.048 ms
[bump] bump-render=normals: FPS: 29599 FrameTime: 0.034 ms
Error: Failed to add fragment shader from file None:
Error: 0(15) : error C0000: syntax error, unexpected identifier, expecting "::" at token "highp"
Error: 0(36) : warning C1503: undefined variable "TextureCoord"
Error: 0(37) : warning C1503: undefined variable "TextureCoord"
Error: 0(38) : warning C1503: undefined variable "TextureCoord"
Error:
[bump] bump-render=height: Set up failed
[effect2d] kernel=0,1,0;1,-4,1;0,1,0;: FPS: 22140 FrameTime: 0.045 ms
[effect2d] kernel=1,1,1,1,1;1,1,1,1,1;1,1,1,1,1;: FPS: 15018 FrameTime: 0.067 ms
[pulsar] light=false:quads=5:texture=false: FPS: 27482 FrameTime: 0.036 ms
[desktop] blur-radius=5:effect=blur:passes=1:separable=true:windows=4: FPS: 8226 FrameTime: 0.122 ms
[desktop] effect=shadow:windows=4: FPS: 10260 FrameTime: 0.097 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 1490 FrameTime: 0.671 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=subdata: FPS: 1613 FrameTime: 0.620 ms
[buffer] columns=200:interleave=true:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 2147 FrameTime: 0.466 ms
[ideas] speed=duration: FPS: 14164 FrameTime: 0.071 ms
[jellyfish] <default>: FPS: 20591 FrameTime: 0.049 ms
Error: Failed to add fragment shader from file None:
Error: 0(26) : warning C7022: unrecognized profile specifier "highp"
Error: 0(26) : error C0502: syntax error at token "highp"
Error:
Error: Failed to add fragment shader from file None:
Error: 0(75) : warning C7022: unrecognized profile specifier "highp"
Error: 0(75) : error C0502: syntax error at token "highp"
Error:
[terrain] <default>:Segmentation fault (core dumped)</pre>
}}

{{collapsible script
| type = details
| title = (click show to expand)
| lang = text
| script =----
glmark2 2021.02
----
OpenGL Information
GL_VENDOR: NVIDIA Corporation
GL_RENDERER: NVIDIA GeForce RTX 2060/PCIe/SSE2
GL_VERSION: 4.6.0 NVIDIA 515.65.01
----
<pre>
[build] use-vbo=false: FPS: 8231 FrameTime: 0.121 ms
[build] use-vbo=true: FPS: 11817 FrameTime: 0.085 ms
[texture] texture-filter=nearest: FPS: 11830 FrameTime: 0.085 ms
[texture] texture-filter=linear: FPS: 11822 FrameTime: 0.085 ms
[texture] texture-filter=mipmap: FPS: 11813 FrameTime: 0.085 ms
[shading] shading=gouraud: FPS: 11501 FrameTime: 0.087 ms
[shading] shading=blinn-phong-inf: FPS: 11429 FrameTime: 0.087 ms
[shading] shading=phong: FPS: 11334 FrameTime: 0.088 ms
[shading] shading=cel: FPS: 11262 FrameTime: 0.089 ms
[bump] bump-render=high-poly: FPS: 10097 FrameTime: 0.099 ms
[bump] bump-render=normals: FPS: 12168 FrameTime: 0.082 ms
[bump] bump-render=height: FPS: 12004 FrameTime: 0.083 ms
[effect2d] kernel=0,1,0;1,-4,1;0,1,0;: FPS: 10522 FrameTime: 0.095 ms
[effect2d] kernel=1,1,1,1,1;1,1,1,1,1;1,1,1,1,1;: FPS: 8468 FrameTime: 0.118 ms
[pulsar] light=false:quads=5:texture=false: FPS: 11776 FrameTime: 0.085 ms
[desktop] blur-radius=5:effect=blur:passes=1:separable=true:windows=4: FPS: 5667 FrameTime: 0.176 ms
[desktop] effect=shadow:windows=4: FPS: 8895 FrameTime: 0.112 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 1796 FrameTime: 0.557 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=subdata: FPS: 2017 FrameTime: 0.496 ms
[buffer] columns=200:interleave=true:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 2176 FrameTime: 0.460 ms
[ideas] speed=duration: FPS: 10641 FrameTime: 0.094 ms
[jellyfish] <default>: FPS: 10085 FrameTime: 0.099 ms
[terrain] <default>: FPS: 1323 FrameTime: 0.756 ms
[shadow] <default>: FPS: 9418 FrameTime: 0.106 ms
[refract] <default>: FPS: 4595 FrameTime: 0.218 ms
[conditionals] fragment-steps=0:vertex-steps=0: FPS: 11552 FrameTime: 0.087 ms
[conditionals] fragment-steps=5:vertex-steps=0: FPS: 11498 FrameTime: 0.087 ms
[conditionals] fragment-steps=0:vertex-steps=5: FPS: 11555 FrameTime: 0.087 ms
[function] fragment-complexity=low:fragment-steps=5: FPS: 11586 FrameTime: 0.086 ms
[function] fragment-complexity=medium:fragment-steps=5: FPS: 11454 FrameTime: 0.087 ms
[loop] fragment-loop=false:fragment-steps=5:vertex-steps=5: FPS: 11521 FrameTime: 0.087 ms
[loop] fragment-steps=5:fragment-uniform=false:vertex-steps=5: FPS: 11495 FrameTime: 0.087 ms
[loop] fragment-steps=5:fragment-uniform=true:vertex-steps=5: FPS: 11403 FrameTime: 0.088 ms</pre>
}}

==== AMD Tahiti XT [Radeon HD 7970 / R9 280X] + Intel Core i5-11600K @ 3.90GHz ====

'''glmark2 Score: 13781'''

{{collapsible script
| type = details
| title = (click show to expand)
| lang = text
| script = ----
glmark2 2021.02
----
OpenGL Information
GL_VENDOR: AMD
GL_RENDERER: AMD TAHITI (DRM 2.50.0, 5.11.0-44-generic, LLVM 12.0.0)
GL_VERSION: 4.5 (Compatibility Profile) Mesa 21.0.3
----
[build] use-vbo=false: FPS: 12290 FrameTime: 0.081 ms
[build] use-vbo=true: FPS: 19086 FrameTime: 0.052 ms
[texture] texture-filter=nearest: FPS: 18131 FrameTime: 0.055 ms
[texture] texture-filter=linear: FPS: 18165 FrameTime: 0.055 ms
[texture] texture-filter=mipmap: FPS: 18563 FrameTime: 0.054 ms
[shading] shading=gouraud: FPS: 16185 FrameTime: 0.062 ms
[shading] shading=blinn-phong-inf: FPS: 16135 FrameTime: 0.062 ms
[shading] shading=phong: FPS: 16042 FrameTime: 0.062 ms
[shading] shading=cel: FPS: 16036 FrameTime: 0.062 ms
[bump] bump-render=high-poly: FPS: 9338 FrameTime: 0.107 ms
[bump] bump-render=normals: FPS: 19774 FrameTime: 0.051 ms
[bump] bump-render=height: FPS: 19534 FrameTime: 0.051 ms
[effect2d] kernel=0,1,0;1,-4,1;0,1,0;: FPS: 15477 FrameTime: 0.065 ms
[effect2d] kernel=1,1,1,1,1;1,1,1,1,1;1,1,1,1,1;: FPS: 10139 FrameTime: 0.099 ms
[pulsar] light=false:quads=5:texture=false: FPS: 16858 FrameTime: 0.059 ms
[desktop] blur-radius=5:effect=blur:passes=1:separable=true:windows=4: FPS: 5961 FrameTime: 0.168 ms
[desktop] effect=shadow:windows=4: FPS: 9994 FrameTime: 0.100 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 2577 FrameTime: 0.388 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=subdata: FPS: 3585 FrameTime: 0.279 ms
[buffer] columns=200:interleave=true:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 3158 FrameTime: 0.317 ms
[ideas] speed=duration: FPS: 11924 FrameTime: 0.084 ms
[jellyfish] <default>: FPS: 12073 FrameTime: 0.083 ms
[terrain] <default>: FPS: 1350 FrameTime: 0.741 ms
[shadow] <default>: FPS: 9986 FrameTime: 0.100 ms
[refract] <default>: FPS: 2500 FrameTime: 0.400 ms
[conditionals] fragment-steps=0:vertex-steps=0: FPS: 18815 FrameTime: 0.053 ms
[conditionals] fragment-steps=5:vertex-steps=0: FPS: 18705 FrameTime: 0.053 ms
[conditionals] fragment-steps=0:vertex-steps=5: FPS: 18787 FrameTime: 0.053 ms
[function] fragment-complexity=low:fragment-steps=5: FPS: 18759 FrameTime: 0.053 ms
[function] fragment-complexity=medium:fragment-steps=5: FPS: 18691 FrameTime: 0.054 ms
[loop] fragment-loop=false:fragment-steps=5:vertex-steps=5: FPS: 18755 FrameTime: 0.053 ms
[loop] fragment-steps=5:fragment-uniform=false:vertex-steps=5: FPS: 18759 FrameTime: 0.053 ms
[loop] fragment-steps=5:fragment-uniform=true:vertex-steps=5: FPS: 18654 FrameTime: 0.054 ms
}}

==== NVIDIA GTX-1060 6GB + AMD R7 3700X @ 4.2 GHz, 8 cores, HT off ====

'''glmark2 Score: 20641'''

{{collapsible script
| type = details
| title = (click show to expand)
| lang = text
| script = ----
glmark2 2014.03+git20150611.fa71af2d
----
OpenGL Information
GL_VENDOR: NVIDIA Corporation
GL_RENDERER: GeForce GTX 1060 6GB/PCIe/SSE2
GL_VERSION: 4.6.0 NVIDIA 460.91.03
----
[build] use-vbo=false: FPS: 15192 FrameTime: 0.066 ms
[build] use-vbo=true: FPS: 30325 FrameTime: 0.033 ms
[texture] texture-filter=nearest: FPS: 27634 FrameTime: 0.036 ms
[texture] texture-filter=linear: FPS: 27511 FrameTime: 0.036 ms
[texture] texture-filter=mipmap: FPS: 28397 FrameTime: 0.035 ms
[shading] shading=gouraud: FPS: 26079 FrameTime: 0.038 ms
[shading] shading=blinn-phong-inf: FPS: 25796 FrameTime: 0.039 ms
[shading] shading=phong: FPS: 25060 FrameTime: 0.040 ms
[shading] shading=cel: FPS: 25321 FrameTime: 0.039 ms
[bump] bump-render=high-poly: FPS: 17451 FrameTime: 0.057 ms
[bump] bump-render=normals: FPS: 31963 FrameTime: 0.031 ms
[bump] bump-render=height: FPS: 31608 FrameTime: 0.032 ms
[effect2d] kernel=0,1,0;1,-4,1;0,1,0;: FPS: 20418 FrameTime: 0.049 ms
[effect2d] kernel=1,1,1,1,1;1,1,1,1,1;1,1,1,1,1;: FPS: 12585 FrameTime: 0.079 ms
[pulsar] light=false:quads=5:texture=false: FPS: 28174 FrameTime: 0.035 ms
[desktop] blur-radius=5:effect=blur:passes=1:separable=true:windows=4: FPS: 7331 FrameTime: 0.136 ms
[desktop] effect=shadow:windows=4: FPS: 14034 FrameTime: 0.071 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 2363 FrameTime: 0.423 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=subdata: FPS: 2783 FrameTime: 0.359 ms
[buffer] columns=200:interleave=true:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 2330 FrameTime: 0.429 ms
[ideas] speed=duration: FPS: 19421 FrameTime: 0.051 ms
[jellyfish] <default>: FPS: 17291 FrameTime: 0.058 ms
[terrain] <default>: FPS: 1349 FrameTime: 0.741 ms
[shadow] <default>: FPS: 15688 FrameTime: 0.064 ms
[refract] <default>: FPS: 4783 FrameTime: 0.209 ms
[conditionals] fragment-steps=0:vertex-steps=0: FPS: 28599 FrameTime: 0.035 ms
[conditionals] fragment-steps=5:vertex-steps=0: FPS: 27499 FrameTime: 0.036 ms
[conditionals] fragment-steps=0:vertex-steps=5: FPS: 28191 FrameTime: 0.035 ms
[function] fragment-complexity=low:fragment-steps=5: FPS: 27695 FrameTime: 0.036 ms
[function] fragment-complexity=medium:fragment-steps=5: FPS: 26605 FrameTime: 0.038 ms
[loop] fragment-loop=false:fragment-steps=5:vertex-steps=5: FPS: 27340 FrameTime: 0.037 ms
[loop] fragment-steps=5:fragment-uniform=false:vertex-steps=5: FPS: 27361 FrameTime: 0.037 ms
[loop] fragment-steps=5:fragment-uniform=true:vertex-steps=5: FPS: 26984 FrameTime: 0.037 ms
}}

==== NVIDIA Quadro K1000M 1GB + Intel Core i7-3610Q @ 2.3 GHz ====
Remark: during glmark2 testing CPU clock boosted to 3.3 GHz

''' glmark2 Score: 2754 '''

{{collapsible script
| type = details
| title = (click show to expand)
| lang = text
| script = ----
glmark2 2014.03+git20150611.fa71af2d
----
OpenGL Information
GL_VENDOR: NVIDIA Corporation
GL_RENDERER: Quadro K1000M/PCIe/SSE2
GL_VERSION: 4.6.0 NVIDIA 390.138
----
[build] use-vbo=false: FPS: 4154 FrameTime: 0.241 ms
[build] use-vbo=true: FPS: 4205 FrameTime: 0.238 ms
[texture] texture-filter=nearest: FPS: 3791 FrameTime: 0.264 ms
[texture] texture-filter=linear: FPS: 3718 FrameTime: 0.269 ms
[texture] texture-filter=mipmap: FPS: 3761 FrameTime: 0.266 ms
[shading] shading=gouraud: FPS: 3187 FrameTime: 0.314 ms
[shading] shading=blinn-phong-inf: FPS: 3200 FrameTime: 0.312 ms
[shading] shading=phong: FPS: 3078 FrameTime: 0.325 ms
[shading] shading=cel: FPS: 3065 FrameTime: 0.326 ms
[bump] bump-render=high-poly: FPS: 1674 FrameTime: 0.597 ms
[bump] bump-render=normals: FPS: 4329 FrameTime: 0.231 ms
[bump] bump-render=height: FPS: 4174 FrameTime: 0.240 ms
[effect2d] kernel=0,1,0;1,-4,1;0,1,0;: FPS: 2356 FrameTime: 0.424 ms
[effect2d] kernel=1,1,1,1,1;1,1,1,1,1;1,1,1,1,1;: FPS: 1249 FrameTime: 0.801 ms
[pulsar] light=false:quads=5:texture=false: FPS: 3550 FrameTime: 0.282 ms
[desktop] blur-radius=5:effect=blur:passes=1:separable=true:windows=4: FPS: 888 FrameTime: 1.126 ms
[desktop] effect=shadow:windows=4: FPS: 1453 FrameTime: 0.688 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 952 FrameTime: 1.050 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=subdata: FPS: 1277 FrameTime: 0.783 ms
[buffer] columns=200:interleave=true:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 977 FrameTime: 1.024 ms
[ideas] speed=duration: FPS: 2926 FrameTime: 0.342 ms
[jellyfish] <default>: FPS: 1551 FrameTime: 0.645 ms
[terrain] <default>: FPS: 173 FrameTime: 5.780 ms
[shadow] <default>: FPS: 2420 FrameTime: 0.413 ms
[refract] <default>: FPS: 431 FrameTime: 2.320 ms
[conditionals] fragment-steps=0:vertex-steps=0: FPS: 3776 FrameTime: 0.265 ms
[conditionals] fragment-steps=5:vertex-steps=0: FPS: 3061 FrameTime: 0.327 ms
[conditionals] fragment-steps=0:vertex-steps=5: FPS: 3776 FrameTime: 0.265 ms
[function] fragment-complexity=low:fragment-steps=5: FPS: 3775 FrameTime: 0.265 ms
[function] fragment-complexity=medium:fragment-steps=5: FPS: 3058 FrameTime: 0.327 ms
[loop] fragment-loop=false:fragment-steps=5:vertex-steps=5: FPS: 3776 FrameTime: 0.265 ms
[loop] fragment-steps=5:fragment-uniform=false:vertex-steps=5: FPS: 3776 FrameTime: 0.265 ms
[loop] fragment-steps=5:fragment-uniform=true:vertex-steps=5: FPS: 3375 FrameTime: 0.296 ms
}}

==== NVIDIA GTX 750 + Intel Core i5-2550K @ 3.4 GHz ====
Remark: no test details available.

'''glmark2 Score: 9000'''

==== NVIDIA GTX 1060 + Intel Core i5-2550K @ 3.4 GHz ====
Remark: no test details available.

'''glmark2 Score: 19000'''

OpenGL performance

2022-08-30T10:27:58Z

MariuszXC: /* NVIDIA Quadro K1000M 1GB + Intel Core i7-3610Q @ 2.3 GHz */

== OpenGL performance ==
{{See also|Profiling performance}}

OpenGL performance can be tested using glmark2 program. It is available in most Linux distributions. In Debian derived distributions (like Ubuntu) it can be installed by issuing ''sudo apt install glmark2'' from command line.

The data presented below was taken by running ''glmark2'' without any additional options, i.e. with default settings, on an otherwise idle system.

By comparing your results with measurements taken on other similar systems you can verify if your hardware and software combination is performing as expected.

=== Integrated graphics ===
==== Intel i5-4310M @ 2.70 GHz (integrated Intel HD 4600 GPU) ====

'''glmark2 Score: 1668'''

{{collapsible script
| type = details
| title = (click show to expand)
| lang = text
| script = ----
glmark2 2014.03+git20150611.fa71af2d
----
OpenGL Information
GL_VENDOR: Intel Open Source Technology Center
GL_RENDERER: Mesa DRI Intel(R) Haswell Mobile
GL_VERSION: 3.0 Mesa 18.0.5
----
<pre>
[build] use-vbo=false: FPS: 2256 FrameTime: 0.443 ms
[build] use-vbo=true: FPS: 2500 FrameTime: 0.400 ms
[texture] texture-filter=nearest: FPS: 2183 FrameTime: 0.458 ms
[texture] texture-filter=linear: FPS: 2180 FrameTime: 0.459 ms
[texture] texture-filter=mipmap: FPS: 2250 FrameTime: 0.444 ms
[shading] shading=gouraud: FPS: 2042 FrameTime: 0.490 ms
[shading] shading=blinn-phong-inf: FPS: 2049 FrameTime: 0.488 ms
[shading] shading=phong: FPS: 1938 FrameTime: 0.516 ms
[shading] shading=cel: FPS: 2037 FrameTime: 0.491 ms
[bump] bump-render=high-poly: FPS: 1701 FrameTime: 0.588 ms
[bump] bump-render=normals: FPS: 2419 FrameTime: 0.413 ms
[bump] bump-render=height: FPS: 2382 FrameTime: 0.420 ms
[effect2d] kernel=0,1,0;1,-4,1;0,1,0;: FPS: 1758 FrameTime: 0.569 ms
[effect2d] kernel=1,1,1,1,1;1,1,1,1,1;1,1,1,1,1;: FPS: 886 FrameTime: 1.129 ms
[pulsar] light=false:quads=5:texture=false: FPS: 2008 FrameTime: 0.498 ms
[desktop] blur-radius=5:effect=blur:passes=1:separable=true:windows=4: FPS: 749 FrameTime: 1.335 ms
[desktop] effect=shadow:windows=4: FPS: 1094 FrameTime: 0.914 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 770 FrameTime: 1.299 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=subdata: FPS: 655 FrameTime: 1.527 ms
[buffer] columns=200:interleave=true:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 857 FrameTime: 1.167 ms
[ideas] speed=duration: FPS: 1776 FrameTime: 0.563 ms
[jellyfish] <default>: FPS: 1275 FrameTime: 0.784 ms
[terrain] <default>: FPS: 173 FrameTime: 5.780 ms
[shadow] <default>: FPS: 805 FrameTime: 1.242 ms
[refract] <default>: FPS: 268 FrameTime: 3.731 ms
[conditionals] fragment-steps=0:vertex-steps=0: FPS: 2038 FrameTime: 0.491 ms
[conditionals] fragment-steps=5:vertex-steps=0: FPS: 2039 FrameTime: 0.490 ms
[conditionals] fragment-steps=0:vertex-steps=5: FPS: 2028 FrameTime: 0.493 ms
[function] fragment-complexity=low:fragment-steps=5: FPS: 2037 FrameTime: 0.491 ms
[function] fragment-complexity=medium:fragment-steps=5: FPS: 2051 FrameTime: 0.488 ms
[loop] fragment-loop=false:fragment-steps=5:vertex-steps=5: FPS: 1879 FrameTime: 0.532 ms
[loop] fragment-steps=5:fragment-uniform=false:vertex-steps=5: FPS: 1922 FrameTime: 0.520 ms
[loop] fragment-steps=5:fragment-uniform=true:vertex-steps=5: FPS: 2039 FrameTime: 0.490 ms</pre>
}}

==== Intel i5-6200U @ 2.3 GHz (integrated Intel UHD 620 GPU) ====
Remark: CPU clock boosted to 2.8 GHz during benchmarking

'''glmark2 Score: 1294'''

{{collapsible script
| type = details
| title = (click show to expand)
| lang = text
| script = ----
glmark2 2021.02
----
OpenGL Information
GL_VENDOR: Intel
GL_RENDERER: Mesa Intel(R) HD Graphics 520 (SKL GT2)
GL_VERSION: 4.6 (Compatibility Profile) Mesa 21.0.3
----
[build] use-vbo=false: FPS: 1500 FrameTime: 0.667 ms
[build] use-vbo=true: FPS: 1959 FrameTime: 0.510 ms
[texture] texture-filter=nearest: FPS: 1722 FrameTime: 0.581 ms
[texture] texture-filter=linear: FPS: 1736 FrameTime: 0.576 ms
[texture] texture-filter=mipmap: FPS: 1673 FrameTime: 0.598 ms
[shading] shading=gouraud: FPS: 1584 FrameTime: 0.631 ms
[shading] shading=blinn-phong-inf: FPS: 1554 FrameTime: 0.644 ms
[shading] shading=phong: FPS: 1559 FrameTime: 0.641 ms
[shading] shading=cel: FPS: 1571 FrameTime: 0.637 ms
[bump] bump-render=high-poly: FPS: 1123 FrameTime: 0.890 ms
[bump] bump-render=normals: FPS: 1945 FrameTime: 0.514 ms
[bump] bump-render=height: FPS: 1881 FrameTime: 0.532 ms
[effect2d] kernel=0,1,0;1,-4,1;0,1,0;: FPS: 1359 FrameTime: 0.736 ms
[effect2d] kernel=1,1,1,1,1;1,1,1,1,1;1,1,1,1,1;: FPS: 851 FrameTime: 1.175 ms
[pulsar] light=false:quads=5:texture=false: FPS: 1646 FrameTime: 0.608 ms
[desktop] blur-radius=5:effect=blur:passes=1:separable=true:windows=4: FPS: 757 FrameTime: 1.321 ms
[desktop] effect=shadow:windows=4: FPS: 1094 FrameTime: 0.914 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 585 FrameTime: 1.709 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=subdata: FPS: 529 FrameTime: 1.890 ms
[buffer] columns=200:interleave=true:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 669 FrameTime: 1.495 ms
[ideas] speed=duration: FPS: 1489 FrameTime: 0.672 ms
[jellyfish] <default>: FPS: 1236 FrameTime: 0.809 ms
[terrain] <default>: FPS: 188 FrameTime: 5.319 ms
[shadow] <default>: FPS: 1014 FrameTime: 0.986 ms
[refract] <default>: FPS: 356 FrameTime: 2.809 ms
[conditionals] fragment-steps=0:vertex-steps=0: FPS: 1360 FrameTime: 0.735 ms
[conditionals] fragment-steps=5:vertex-steps=0: FPS: 1407 FrameTime: 0.711 ms
[conditionals] fragment-steps=0:vertex-steps=5: FPS: 1393 FrameTime: 0.718 ms
[function] fragment-complexity=low:fragment-steps=5: FPS: 1412 FrameTime: 0.708 ms
[function] fragment-complexity=medium:fragment-steps=5: FPS: 1416 FrameTime: 0.706 ms
[loop] fragment-loop=false:fragment-steps=5:vertex-steps=5: FPS: 1369 FrameTime: 0.730 ms
[loop] fragment-steps=5:fragment-uniform=false:vertex-steps=5: FPS: 1388 FrameTime: 0.720 ms
[loop] fragment-steps=5:fragment-uniform=true:vertex-steps=5: FPS: 1383 FrameTime: 0.723 ms
}}

=== Discrete graphics card ===
Note: this section also contains hybrid configurations (e.g. laptops with dual GPU technology)

==== AMD FirePro M5950 + Intel i5-2520M ====
Remark: dual GPU technology laptop, no test details available.

'''glmark2 Score: 5600'''

==== NVIDIA RTX2060 6GB + AMD Ryzen 7 3700X 8-Core 4GHz ====
Note: one tests resulted in errors and finally a core dump.
Another test on the same hardware, with different drivers, completed.
Both test details are included.

'''glmark2 Score: 9537'''

{{collapsible script
| type = details
| title = (click show to expand)
| lang = text
| script =----
glmark2 2021.02
----
OpenGL Information
GL_VENDOR: NVIDIA Corporation
GL_RENDERER: NVIDIA GeForce RTX 2060/PCIe/SSE2
GL_VERSION: 4.6.0 NVIDIA 495.46
----
<pre>
[build] use-vbo=false: FPS: 13809 FrameTime: 0.072 ms
[build] use-vbo=true: FPS: 28367 FrameTime: 0.035 ms
[texture] texture-filter=nearest: FPS: 27958 FrameTime: 0.036 ms
[texture] texture-filter=linear: FPS: 28120 FrameTime: 0.036 ms
[texture] texture-filter=mipmap: FPS: 28036 FrameTime: 0.036 ms
[shading] shading=gouraud: FPS: 26428 FrameTime: 0.038 ms
[shading] shading=blinn-phong-inf: FPS: 26320 FrameTime: 0.038 ms
[shading] shading=phong: FPS: 25800 FrameTime: 0.039 ms
[shading] shading=cel: FPS: 25498 FrameTime: 0.039 ms
[bump] bump-render=high-poly: FPS: 20696 FrameTime: 0.048 ms
[bump] bump-render=normals: FPS: 29599 FrameTime: 0.034 ms
Error: Failed to add fragment shader from file None:
Error: 0(15) : error C0000: syntax error, unexpected identifier, expecting "::" at token "highp"
Error: 0(36) : warning C1503: undefined variable "TextureCoord"
Error: 0(37) : warning C1503: undefined variable "TextureCoord"
Error: 0(38) : warning C1503: undefined variable "TextureCoord"
Error:
[bump] bump-render=height: Set up failed
[effect2d] kernel=0,1,0;1,-4,1;0,1,0;: FPS: 22140 FrameTime: 0.045 ms
[effect2d] kernel=1,1,1,1,1;1,1,1,1,1;1,1,1,1,1;: FPS: 15018 FrameTime: 0.067 ms
[pulsar] light=false:quads=5:texture=false: FPS: 27482 FrameTime: 0.036 ms
[desktop] blur-radius=5:effect=blur:passes=1:separable=true:windows=4: FPS: 8226 FrameTime: 0.122 ms
[desktop] effect=shadow:windows=4: FPS: 10260 FrameTime: 0.097 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 1490 FrameTime: 0.671 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=subdata: FPS: 1613 FrameTime: 0.620 ms
[buffer] columns=200:interleave=true:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 2147 FrameTime: 0.466 ms
[ideas] speed=duration: FPS: 14164 FrameTime: 0.071 ms
[jellyfish] <default>: FPS: 20591 FrameTime: 0.049 ms
Error: Failed to add fragment shader from file None:
Error: 0(26) : warning C7022: unrecognized profile specifier "highp"
Error: 0(26) : error C0502: syntax error at token "highp"
Error:
Error: Failed to add fragment shader from file None:
Error: 0(75) : warning C7022: unrecognized profile specifier "highp"
Error: 0(75) : error C0502: syntax error at token "highp"
Error:
[terrain] <default>:Segmentation fault (core dumped)</pre>
}}

{{collapsible script
| type = details
| title = (click show to expand)
| lang = text
| script =----
glmark2 2021.02
----
OpenGL Information
GL_VENDOR: NVIDIA Corporation
GL_RENDERER: NVIDIA GeForce RTX 2060/PCIe/SSE2
GL_VERSION: 4.6.0 NVIDIA 515.65.01
----
<pre>
[build] use-vbo=false: FPS: 8231 FrameTime: 0.121 ms
[build] use-vbo=true: FPS: 11817 FrameTime: 0.085 ms
[texture] texture-filter=nearest: FPS: 11830 FrameTime: 0.085 ms
[texture] texture-filter=linear: FPS: 11822 FrameTime: 0.085 ms
[texture] texture-filter=mipmap: FPS: 11813 FrameTime: 0.085 ms
[shading] shading=gouraud: FPS: 11501 FrameTime: 0.087 ms
[shading] shading=blinn-phong-inf: FPS: 11429 FrameTime: 0.087 ms
[shading] shading=phong: FPS: 11334 FrameTime: 0.088 ms
[shading] shading=cel: FPS: 11262 FrameTime: 0.089 ms
[bump] bump-render=high-poly: FPS: 10097 FrameTime: 0.099 ms
[bump] bump-render=normals: FPS: 12168 FrameTime: 0.082 ms
[bump] bump-render=height: FPS: 12004 FrameTime: 0.083 ms
[effect2d] kernel=0,1,0;1,-4,1;0,1,0;: FPS: 10522 FrameTime: 0.095 ms
[effect2d] kernel=1,1,1,1,1;1,1,1,1,1;1,1,1,1,1;: FPS: 8468 FrameTime: 0.118 ms
[pulsar] light=false:quads=5:texture=false: FPS: 11776 FrameTime: 0.085 ms
[desktop] blur-radius=5:effect=blur:passes=1:separable=true:windows=4: FPS: 5667 FrameTime: 0.176 ms
[desktop] effect=shadow:windows=4: FPS: 8895 FrameTime: 0.112 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 1796 FrameTime: 0.557 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=subdata: FPS: 2017 FrameTime: 0.496 ms
[buffer] columns=200:interleave=true:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 2176 FrameTime: 0.460 ms
[ideas] speed=duration: FPS: 10641 FrameTime: 0.094 ms
[jellyfish] <default>: FPS: 10085 FrameTime: 0.099 ms
[terrain] <default>: FPS: 1323 FrameTime: 0.756 ms
[shadow] <default>: FPS: 9418 FrameTime: 0.106 ms
[refract] <default>: FPS: 4595 FrameTime: 0.218 ms
[conditionals] fragment-steps=0:vertex-steps=0: FPS: 11552 FrameTime: 0.087 ms
[conditionals] fragment-steps=5:vertex-steps=0: FPS: 11498 FrameTime: 0.087 ms
[conditionals] fragment-steps=0:vertex-steps=5: FPS: 11555 FrameTime: 0.087 ms
[function] fragment-complexity=low:fragment-steps=5: FPS: 11586 FrameTime: 0.086 ms
[function] fragment-complexity=medium:fragment-steps=5: FPS: 11454 FrameTime: 0.087 ms
[loop] fragment-loop=false:fragment-steps=5:vertex-steps=5: FPS: 11521 FrameTime: 0.087 ms
[loop] fragment-steps=5:fragment-uniform=false:vertex-steps=5: FPS: 11495 FrameTime: 0.087 ms
[loop] fragment-steps=5:fragment-uniform=true:vertex-steps=5: FPS: 11403 FrameTime: 0.088 ms</pre>
}}

==== AMD Tahiti XT [Radeon HD 7970 / R9 280X] + Intel Core i5-11600K @ 3.90GHz ====

'''glmark2 Score: 13781'''

{{collapsible script
| type = details
| title = (click show to expand)
| lang = text
| script = ----
glmark2 2021.02
----
OpenGL Information
GL_VENDOR: AMD
GL_RENDERER: AMD TAHITI (DRM 2.50.0, 5.11.0-44-generic, LLVM 12.0.0)
GL_VERSION: 4.5 (Compatibility Profile) Mesa 21.0.3
----
[build] use-vbo=false: FPS: 12290 FrameTime: 0.081 ms
[build] use-vbo=true: FPS: 19086 FrameTime: 0.052 ms
[texture] texture-filter=nearest: FPS: 18131 FrameTime: 0.055 ms
[texture] texture-filter=linear: FPS: 18165 FrameTime: 0.055 ms
[texture] texture-filter=mipmap: FPS: 18563 FrameTime: 0.054 ms
[shading] shading=gouraud: FPS: 16185 FrameTime: 0.062 ms
[shading] shading=blinn-phong-inf: FPS: 16135 FrameTime: 0.062 ms
[shading] shading=phong: FPS: 16042 FrameTime: 0.062 ms
[shading] shading=cel: FPS: 16036 FrameTime: 0.062 ms
[bump] bump-render=high-poly: FPS: 9338 FrameTime: 0.107 ms
[bump] bump-render=normals: FPS: 19774 FrameTime: 0.051 ms
[bump] bump-render=height: FPS: 19534 FrameTime: 0.051 ms
[effect2d] kernel=0,1,0;1,-4,1;0,1,0;: FPS: 15477 FrameTime: 0.065 ms
[effect2d] kernel=1,1,1,1,1;1,1,1,1,1;1,1,1,1,1;: FPS: 10139 FrameTime: 0.099 ms
[pulsar] light=false:quads=5:texture=false: FPS: 16858 FrameTime: 0.059 ms
[desktop] blur-radius=5:effect=blur:passes=1:separable=true:windows=4: FPS: 5961 FrameTime: 0.168 ms
[desktop] effect=shadow:windows=4: FPS: 9994 FrameTime: 0.100 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 2577 FrameTime: 0.388 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=subdata: FPS: 3585 FrameTime: 0.279 ms
[buffer] columns=200:interleave=true:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 3158 FrameTime: 0.317 ms
[ideas] speed=duration: FPS: 11924 FrameTime: 0.084 ms
[jellyfish] <default>: FPS: 12073 FrameTime: 0.083 ms
[terrain] <default>: FPS: 1350 FrameTime: 0.741 ms
[shadow] <default>: FPS: 9986 FrameTime: 0.100 ms
[refract] <default>: FPS: 2500 FrameTime: 0.400 ms
[conditionals] fragment-steps=0:vertex-steps=0: FPS: 18815 FrameTime: 0.053 ms
[conditionals] fragment-steps=5:vertex-steps=0: FPS: 18705 FrameTime: 0.053 ms
[conditionals] fragment-steps=0:vertex-steps=5: FPS: 18787 FrameTime: 0.053 ms
[function] fragment-complexity=low:fragment-steps=5: FPS: 18759 FrameTime: 0.053 ms
[function] fragment-complexity=medium:fragment-steps=5: FPS: 18691 FrameTime: 0.054 ms
[loop] fragment-loop=false:fragment-steps=5:vertex-steps=5: FPS: 18755 FrameTime: 0.053 ms
[loop] fragment-steps=5:fragment-uniform=false:vertex-steps=5: FPS: 18759 FrameTime: 0.053 ms
[loop] fragment-steps=5:fragment-uniform=true:vertex-steps=5: FPS: 18654 FrameTime: 0.054 ms
}}

==== NVIDIA GTX-1060 6GB + AMD R7 3700X @ 4.2 GHz, 8 cores, HT off ====

'''glmark2 Score: 20641'''

{{collapsible script
| type = details
| title = (click show to expand)
| lang = text
| script = ----
glmark2 2014.03+git20150611.fa71af2d
----
OpenGL Information
GL_VENDOR: NVIDIA Corporation
GL_RENDERER: GeForce GTX 1060 6GB/PCIe/SSE2
GL_VERSION: 4.6.0 NVIDIA 460.91.03
----
[build] use-vbo=false: FPS: 15192 FrameTime: 0.066 ms
[build] use-vbo=true: FPS: 30325 FrameTime: 0.033 ms
[texture] texture-filter=nearest: FPS: 27634 FrameTime: 0.036 ms
[texture] texture-filter=linear: FPS: 27511 FrameTime: 0.036 ms
[texture] texture-filter=mipmap: FPS: 28397 FrameTime: 0.035 ms
[shading] shading=gouraud: FPS: 26079 FrameTime: 0.038 ms
[shading] shading=blinn-phong-inf: FPS: 25796 FrameTime: 0.039 ms
[shading] shading=phong: FPS: 25060 FrameTime: 0.040 ms
[shading] shading=cel: FPS: 25321 FrameTime: 0.039 ms
[bump] bump-render=high-poly: FPS: 17451 FrameTime: 0.057 ms
[bump] bump-render=normals: FPS: 31963 FrameTime: 0.031 ms
[bump] bump-render=height: FPS: 31608 FrameTime: 0.032 ms
[effect2d] kernel=0,1,0;1,-4,1;0,1,0;: FPS: 20418 FrameTime: 0.049 ms
[effect2d] kernel=1,1,1,1,1;1,1,1,1,1;1,1,1,1,1;: FPS: 12585 FrameTime: 0.079 ms
[pulsar] light=false:quads=5:texture=false: FPS: 28174 FrameTime: 0.035 ms
[desktop] blur-radius=5:effect=blur:passes=1:separable=true:windows=4: FPS: 7331 FrameTime: 0.136 ms
[desktop] effect=shadow:windows=4: FPS: 14034 FrameTime: 0.071 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 2363 FrameTime: 0.423 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=subdata: FPS: 2783 FrameTime: 0.359 ms
[buffer] columns=200:interleave=true:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 2330 FrameTime: 0.429 ms
[ideas] speed=duration: FPS: 19421 FrameTime: 0.051 ms
[jellyfish] <default>: FPS: 17291 FrameTime: 0.058 ms
[terrain] <default>: FPS: 1349 FrameTime: 0.741 ms
[shadow] <default>: FPS: 15688 FrameTime: 0.064 ms
[refract] <default>: FPS: 4783 FrameTime: 0.209 ms
[conditionals] fragment-steps=0:vertex-steps=0: FPS: 28599 FrameTime: 0.035 ms
[conditionals] fragment-steps=5:vertex-steps=0: FPS: 27499 FrameTime: 0.036 ms
[conditionals] fragment-steps=0:vertex-steps=5: FPS: 28191 FrameTime: 0.035 ms
[function] fragment-complexity=low:fragment-steps=5: FPS: 27695 FrameTime: 0.036 ms
[function] fragment-complexity=medium:fragment-steps=5: FPS: 26605 FrameTime: 0.038 ms
[loop] fragment-loop=false:fragment-steps=5:vertex-steps=5: FPS: 27340 FrameTime: 0.037 ms
[loop] fragment-steps=5:fragment-uniform=false:vertex-steps=5: FPS: 27361 FrameTime: 0.037 ms
[loop] fragment-steps=5:fragment-uniform=true:vertex-steps=5: FPS: 26984 FrameTime: 0.037 ms
}}

==== NVIDIA Quadro K1000M 1GB + Intel Core i7-3610Q @ 2.3 GHz ====
Remark: during glmark2 testing CPU clock boosted to 3.3 GHz

''' glmark2 Score: 2754 '''

{{collapsible script
| type = details
| title = (click show to expand)
| lang = text
| script = ----
glmark2 2014.03+git20150611.fa71af2d
----
OpenGL Information
GL_VENDOR: NVIDIA Corporation
GL_RENDERER: Quadro K1000M/PCIe/SSE2
GL_VERSION: 4.6.0 NVIDIA 390.138
----
[build] use-vbo=false: FPS: 4154 FrameTime: 0.241 ms
[build] use-vbo=true: FPS: 4205 FrameTime: 0.238 ms
[texture] texture-filter=nearest: FPS: 3791 FrameTime: 0.264 ms
[texture] texture-filter=linear: FPS: 3718 FrameTime: 0.269 ms
[texture] texture-filter=mipmap: FPS: 3761 FrameTime: 0.266 ms
[shading] shading=gouraud: FPS: 3187 FrameTime: 0.314 ms
[shading] shading=blinn-phong-inf: FPS: 3200 FrameTime: 0.312 ms
[shading] shading=phong: FPS: 3078 FrameTime: 0.325 ms
[shading] shading=cel: FPS: 3065 FrameTime: 0.326 ms
[bump] bump-render=high-poly: FPS: 1674 FrameTime: 0.597 ms
[bump] bump-render=normals: FPS: 4329 FrameTime: 0.231 ms
[bump] bump-render=height: FPS: 4174 FrameTime: 0.240 ms
[effect2d] kernel=0,1,0;1,-4,1;0,1,0;: FPS: 2356 FrameTime: 0.424 ms
[effect2d] kernel=1,1,1,1,1;1,1,1,1,1;1,1,1,1,1;: FPS: 1249 FrameTime: 0.801 ms
[pulsar] light=false:quads=5:texture=false: FPS: 3550 FrameTime: 0.282 ms
[desktop] blur-radius=5:effect=blur:passes=1:separable=true:windows=4: FPS: 888 FrameTime: 1.126 ms
[desktop] effect=shadow:windows=4: FPS: 1453 FrameTime: 0.688 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 952 FrameTime: 1.050 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=subdata: FPS: 1277 FrameTime: 0.783 ms
[buffer] columns=200:interleave=true:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 977 FrameTime: 1.024 ms
[ideas] speed=duration: FPS: 2926 FrameTime: 0.342 ms
[jellyfish] <default>: FPS: 1551 FrameTime: 0.645 ms
[terrain] <default>: FPS: 173 FrameTime: 5.780 ms
[shadow] <default>: FPS: 2420 FrameTime: 0.413 ms
[refract] <default>: FPS: 431 FrameTime: 2.320 ms
[conditionals] fragment-steps=0:vertex-steps=0: FPS: 3776 FrameTime: 0.265 ms
[conditionals] fragment-steps=5:vertex-steps=0: FPS: 3061 FrameTime: 0.327 ms
[conditionals] fragment-steps=0:vertex-steps=5: FPS: 3776 FrameTime: 0.265 ms
[function] fragment-complexity=low:fragment-steps=5: FPS: 3775 FrameTime: 0.265 ms
[function] fragment-complexity=medium:fragment-steps=5: FPS: 3058 FrameTime: 0.327 ms
[loop] fragment-loop=false:fragment-steps=5:vertex-steps=5: FPS: 3776 FrameTime: 0.265 ms
[loop] fragment-steps=5:fragment-uniform=false:vertex-steps=5: FPS: 3776 FrameTime: 0.265 ms
[loop] fragment-steps=5:fragment-uniform=true:vertex-steps=5: FPS: 3375 FrameTime: 0.296 ms
}}

==== NVIDIA GTX 750 + Intel Core i5-2550K @ 3.4 GHz ====
Remark: no test details available.

'''glmark2 Score: 9000'''

==== NVIDIA GTX 1060 + Intel Core i5-2550K @ 3.4 GHz ====
Remark: no test details available.

'''glmark2 Score: 19000'''

OpenGL performance

2022-08-30T10:26:40Z

MariuszXC: /* NVIDIA GTX-1060 6GB + AMD R7 3700X @ 4.2 GHz, 8 cores, HT off */

== OpenGL performance ==
{{See also|Profiling performance}}

OpenGL performance can be tested using glmark2 program. It is available in most Linux distributions. In Debian derived distributions (like Ubuntu) it can be installed by issuing ''sudo apt install glmark2'' from command line.

The data presented below was taken by running ''glmark2'' without any additional options, i.e. with default settings, on an otherwise idle system.

By comparing your results with measurements taken on other similar systems you can verify if your hardware and software combination is performing as expected.

=== Integrated graphics ===
==== Intel i5-4310M @ 2.70 GHz (integrated Intel HD 4600 GPU) ====

'''glmark2 Score: 1668'''

{{collapsible script
| type = details
| title = (click show to expand)
| lang = text
| script = ----
glmark2 2014.03+git20150611.fa71af2d
----
OpenGL Information
GL_VENDOR: Intel Open Source Technology Center
GL_RENDERER: Mesa DRI Intel(R) Haswell Mobile
GL_VERSION: 3.0 Mesa 18.0.5
----
<pre>
[build] use-vbo=false: FPS: 2256 FrameTime: 0.443 ms
[build] use-vbo=true: FPS: 2500 FrameTime: 0.400 ms
[texture] texture-filter=nearest: FPS: 2183 FrameTime: 0.458 ms
[texture] texture-filter=linear: FPS: 2180 FrameTime: 0.459 ms
[texture] texture-filter=mipmap: FPS: 2250 FrameTime: 0.444 ms
[shading] shading=gouraud: FPS: 2042 FrameTime: 0.490 ms
[shading] shading=blinn-phong-inf: FPS: 2049 FrameTime: 0.488 ms
[shading] shading=phong: FPS: 1938 FrameTime: 0.516 ms
[shading] shading=cel: FPS: 2037 FrameTime: 0.491 ms
[bump] bump-render=high-poly: FPS: 1701 FrameTime: 0.588 ms
[bump] bump-render=normals: FPS: 2419 FrameTime: 0.413 ms
[bump] bump-render=height: FPS: 2382 FrameTime: 0.420 ms
[effect2d] kernel=0,1,0;1,-4,1;0,1,0;: FPS: 1758 FrameTime: 0.569 ms
[effect2d] kernel=1,1,1,1,1;1,1,1,1,1;1,1,1,1,1;: FPS: 886 FrameTime: 1.129 ms
[pulsar] light=false:quads=5:texture=false: FPS: 2008 FrameTime: 0.498 ms
[desktop] blur-radius=5:effect=blur:passes=1:separable=true:windows=4: FPS: 749 FrameTime: 1.335 ms
[desktop] effect=shadow:windows=4: FPS: 1094 FrameTime: 0.914 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 770 FrameTime: 1.299 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=subdata: FPS: 655 FrameTime: 1.527 ms
[buffer] columns=200:interleave=true:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 857 FrameTime: 1.167 ms
[ideas] speed=duration: FPS: 1776 FrameTime: 0.563 ms
[jellyfish] <default>: FPS: 1275 FrameTime: 0.784 ms
[terrain] <default>: FPS: 173 FrameTime: 5.780 ms
[shadow] <default>: FPS: 805 FrameTime: 1.242 ms
[refract] <default>: FPS: 268 FrameTime: 3.731 ms
[conditionals] fragment-steps=0:vertex-steps=0: FPS: 2038 FrameTime: 0.491 ms
[conditionals] fragment-steps=5:vertex-steps=0: FPS: 2039 FrameTime: 0.490 ms
[conditionals] fragment-steps=0:vertex-steps=5: FPS: 2028 FrameTime: 0.493 ms
[function] fragment-complexity=low:fragment-steps=5: FPS: 2037 FrameTime: 0.491 ms
[function] fragment-complexity=medium:fragment-steps=5: FPS: 2051 FrameTime: 0.488 ms
[loop] fragment-loop=false:fragment-steps=5:vertex-steps=5: FPS: 1879 FrameTime: 0.532 ms
[loop] fragment-steps=5:fragment-uniform=false:vertex-steps=5: FPS: 1922 FrameTime: 0.520 ms
[loop] fragment-steps=5:fragment-uniform=true:vertex-steps=5: FPS: 2039 FrameTime: 0.490 ms</pre>
}}

==== Intel i5-6200U @ 2.3 GHz (integrated Intel UHD 620 GPU) ====
Remark: CPU clock boosted to 2.8 GHz during benchmarking

'''glmark2 Score: 1294'''

{{collapsible script
| type = details
| title = (click show to expand)
| lang = text
| script = ----
glmark2 2021.02
----
OpenGL Information
GL_VENDOR: Intel
GL_RENDERER: Mesa Intel(R) HD Graphics 520 (SKL GT2)
GL_VERSION: 4.6 (Compatibility Profile) Mesa 21.0.3
----
[build] use-vbo=false: FPS: 1500 FrameTime: 0.667 ms
[build] use-vbo=true: FPS: 1959 FrameTime: 0.510 ms
[texture] texture-filter=nearest: FPS: 1722 FrameTime: 0.581 ms
[texture] texture-filter=linear: FPS: 1736 FrameTime: 0.576 ms
[texture] texture-filter=mipmap: FPS: 1673 FrameTime: 0.598 ms
[shading] shading=gouraud: FPS: 1584 FrameTime: 0.631 ms
[shading] shading=blinn-phong-inf: FPS: 1554 FrameTime: 0.644 ms
[shading] shading=phong: FPS: 1559 FrameTime: 0.641 ms
[shading] shading=cel: FPS: 1571 FrameTime: 0.637 ms
[bump] bump-render=high-poly: FPS: 1123 FrameTime: 0.890 ms
[bump] bump-render=normals: FPS: 1945 FrameTime: 0.514 ms
[bump] bump-render=height: FPS: 1881 FrameTime: 0.532 ms
[effect2d] kernel=0,1,0;1,-4,1;0,1,0;: FPS: 1359 FrameTime: 0.736 ms
[effect2d] kernel=1,1,1,1,1;1,1,1,1,1;1,1,1,1,1;: FPS: 851 FrameTime: 1.175 ms
[pulsar] light=false:quads=5:texture=false: FPS: 1646 FrameTime: 0.608 ms
[desktop] blur-radius=5:effect=blur:passes=1:separable=true:windows=4: FPS: 757 FrameTime: 1.321 ms
[desktop] effect=shadow:windows=4: FPS: 1094 FrameTime: 0.914 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 585 FrameTime: 1.709 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=subdata: FPS: 529 FrameTime: 1.890 ms
[buffer] columns=200:interleave=true:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 669 FrameTime: 1.495 ms
[ideas] speed=duration: FPS: 1489 FrameTime: 0.672 ms
[jellyfish] <default>: FPS: 1236 FrameTime: 0.809 ms
[terrain] <default>: FPS: 188 FrameTime: 5.319 ms
[shadow] <default>: FPS: 1014 FrameTime: 0.986 ms
[refract] <default>: FPS: 356 FrameTime: 2.809 ms
[conditionals] fragment-steps=0:vertex-steps=0: FPS: 1360 FrameTime: 0.735 ms
[conditionals] fragment-steps=5:vertex-steps=0: FPS: 1407 FrameTime: 0.711 ms
[conditionals] fragment-steps=0:vertex-steps=5: FPS: 1393 FrameTime: 0.718 ms
[function] fragment-complexity=low:fragment-steps=5: FPS: 1412 FrameTime: 0.708 ms
[function] fragment-complexity=medium:fragment-steps=5: FPS: 1416 FrameTime: 0.706 ms
[loop] fragment-loop=false:fragment-steps=5:vertex-steps=5: FPS: 1369 FrameTime: 0.730 ms
[loop] fragment-steps=5:fragment-uniform=false:vertex-steps=5: FPS: 1388 FrameTime: 0.720 ms
[loop] fragment-steps=5:fragment-uniform=true:vertex-steps=5: FPS: 1383 FrameTime: 0.723 ms
}}

=== Discrete graphics card ===
Note: this section also contains hybrid configurations (e.g. laptops with dual GPU technology)

==== AMD FirePro M5950 + Intel i5-2520M ====
Remark: dual GPU technology laptop, no test details available.

'''glmark2 Score: 5600'''

==== NVIDIA RTX2060 6GB + AMD Ryzen 7 3700X 8-Core 4GHz ====
Note: one tests resulted in errors and finally a core dump.
Another test on the same hardware, with different drivers, completed.
Both test details are included.

'''glmark2 Score: 9537'''

{{collapsible script
| type = details
| title = (click show to expand)
| lang = text
| script =----
glmark2 2021.02
----
OpenGL Information
GL_VENDOR: NVIDIA Corporation
GL_RENDERER: NVIDIA GeForce RTX 2060/PCIe/SSE2
GL_VERSION: 4.6.0 NVIDIA 495.46
----
<pre>
[build] use-vbo=false: FPS: 13809 FrameTime: 0.072 ms
[build] use-vbo=true: FPS: 28367 FrameTime: 0.035 ms
[texture] texture-filter=nearest: FPS: 27958 FrameTime: 0.036 ms
[texture] texture-filter=linear: FPS: 28120 FrameTime: 0.036 ms
[texture] texture-filter=mipmap: FPS: 28036 FrameTime: 0.036 ms
[shading] shading=gouraud: FPS: 26428 FrameTime: 0.038 ms
[shading] shading=blinn-phong-inf: FPS: 26320 FrameTime: 0.038 ms
[shading] shading=phong: FPS: 25800 FrameTime: 0.039 ms
[shading] shading=cel: FPS: 25498 FrameTime: 0.039 ms
[bump] bump-render=high-poly: FPS: 20696 FrameTime: 0.048 ms
[bump] bump-render=normals: FPS: 29599 FrameTime: 0.034 ms
Error: Failed to add fragment shader from file None:
Error: 0(15) : error C0000: syntax error, unexpected identifier, expecting "::" at token "highp"
Error: 0(36) : warning C1503: undefined variable "TextureCoord"
Error: 0(37) : warning C1503: undefined variable "TextureCoord"
Error: 0(38) : warning C1503: undefined variable "TextureCoord"
Error:
[bump] bump-render=height: Set up failed
[effect2d] kernel=0,1,0;1,-4,1;0,1,0;: FPS: 22140 FrameTime: 0.045 ms
[effect2d] kernel=1,1,1,1,1;1,1,1,1,1;1,1,1,1,1;: FPS: 15018 FrameTime: 0.067 ms
[pulsar] light=false:quads=5:texture=false: FPS: 27482 FrameTime: 0.036 ms
[desktop] blur-radius=5:effect=blur:passes=1:separable=true:windows=4: FPS: 8226 FrameTime: 0.122 ms
[desktop] effect=shadow:windows=4: FPS: 10260 FrameTime: 0.097 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 1490 FrameTime: 0.671 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=subdata: FPS: 1613 FrameTime: 0.620 ms
[buffer] columns=200:interleave=true:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 2147 FrameTime: 0.466 ms
[ideas] speed=duration: FPS: 14164 FrameTime: 0.071 ms
[jellyfish] <default>: FPS: 20591 FrameTime: 0.049 ms
Error: Failed to add fragment shader from file None:
Error: 0(26) : warning C7022: unrecognized profile specifier "highp"
Error: 0(26) : error C0502: syntax error at token "highp"
Error:
Error: Failed to add fragment shader from file None:
Error: 0(75) : warning C7022: unrecognized profile specifier "highp"
Error: 0(75) : error C0502: syntax error at token "highp"
Error:
[terrain] <default>:Segmentation fault (core dumped)</pre>
}}

{{collapsible script
| type = details
| title = (click show to expand)
| lang = text
| script =----
glmark2 2021.02
----
OpenGL Information
GL_VENDOR: NVIDIA Corporation
GL_RENDERER: NVIDIA GeForce RTX 2060/PCIe/SSE2
GL_VERSION: 4.6.0 NVIDIA 515.65.01
----
<pre>
[build] use-vbo=false: FPS: 8231 FrameTime: 0.121 ms
[build] use-vbo=true: FPS: 11817 FrameTime: 0.085 ms
[texture] texture-filter=nearest: FPS: 11830 FrameTime: 0.085 ms
[texture] texture-filter=linear: FPS: 11822 FrameTime: 0.085 ms
[texture] texture-filter=mipmap: FPS: 11813 FrameTime: 0.085 ms
[shading] shading=gouraud: FPS: 11501 FrameTime: 0.087 ms
[shading] shading=blinn-phong-inf: FPS: 11429 FrameTime: 0.087 ms
[shading] shading=phong: FPS: 11334 FrameTime: 0.088 ms
[shading] shading=cel: FPS: 11262 FrameTime: 0.089 ms
[bump] bump-render=high-poly: FPS: 10097 FrameTime: 0.099 ms
[bump] bump-render=normals: FPS: 12168 FrameTime: 0.082 ms
[bump] bump-render=height: FPS: 12004 FrameTime: 0.083 ms
[effect2d] kernel=0,1,0;1,-4,1;0,1,0;: FPS: 10522 FrameTime: 0.095 ms
[effect2d] kernel=1,1,1,1,1;1,1,1,1,1;1,1,1,1,1;: FPS: 8468 FrameTime: 0.118 ms
[pulsar] light=false:quads=5:texture=false: FPS: 11776 FrameTime: 0.085 ms
[desktop] blur-radius=5:effect=blur:passes=1:separable=true:windows=4: FPS: 5667 FrameTime: 0.176 ms
[desktop] effect=shadow:windows=4: FPS: 8895 FrameTime: 0.112 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 1796 FrameTime: 0.557 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=subdata: FPS: 2017 FrameTime: 0.496 ms
[buffer] columns=200:interleave=true:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 2176 FrameTime: 0.460 ms
[ideas] speed=duration: FPS: 10641 FrameTime: 0.094 ms
[jellyfish] <default>: FPS: 10085 FrameTime: 0.099 ms
[terrain] <default>: FPS: 1323 FrameTime: 0.756 ms
[shadow] <default>: FPS: 9418 FrameTime: 0.106 ms
[refract] <default>: FPS: 4595 FrameTime: 0.218 ms
[conditionals] fragment-steps=0:vertex-steps=0: FPS: 11552 FrameTime: 0.087 ms
[conditionals] fragment-steps=5:vertex-steps=0: FPS: 11498 FrameTime: 0.087 ms
[conditionals] fragment-steps=0:vertex-steps=5: FPS: 11555 FrameTime: 0.087 ms
[function] fragment-complexity=low:fragment-steps=5: FPS: 11586 FrameTime: 0.086 ms
[function] fragment-complexity=medium:fragment-steps=5: FPS: 11454 FrameTime: 0.087 ms
[loop] fragment-loop=false:fragment-steps=5:vertex-steps=5: FPS: 11521 FrameTime: 0.087 ms
[loop] fragment-steps=5:fragment-uniform=false:vertex-steps=5: FPS: 11495 FrameTime: 0.087 ms
[loop] fragment-steps=5:fragment-uniform=true:vertex-steps=5: FPS: 11403 FrameTime: 0.088 ms</pre>
}}

==== AMD Tahiti XT [Radeon HD 7970 / R9 280X] + Intel Core i5-11600K @ 3.90GHz ====

'''glmark2 Score: 13781'''

{{collapsible script
| type = details
| title = (click show to expand)
| lang = text
| script = ----
glmark2 2021.02
----
OpenGL Information
GL_VENDOR: AMD
GL_RENDERER: AMD TAHITI (DRM 2.50.0, 5.11.0-44-generic, LLVM 12.0.0)
GL_VERSION: 4.5 (Compatibility Profile) Mesa 21.0.3
----
[build] use-vbo=false: FPS: 12290 FrameTime: 0.081 ms
[build] use-vbo=true: FPS: 19086 FrameTime: 0.052 ms
[texture] texture-filter=nearest: FPS: 18131 FrameTime: 0.055 ms
[texture] texture-filter=linear: FPS: 18165 FrameTime: 0.055 ms
[texture] texture-filter=mipmap: FPS: 18563 FrameTime: 0.054 ms
[shading] shading=gouraud: FPS: 16185 FrameTime: 0.062 ms
[shading] shading=blinn-phong-inf: FPS: 16135 FrameTime: 0.062 ms
[shading] shading=phong: FPS: 16042 FrameTime: 0.062 ms
[shading] shading=cel: FPS: 16036 FrameTime: 0.062 ms
[bump] bump-render=high-poly: FPS: 9338 FrameTime: 0.107 ms
[bump] bump-render=normals: FPS: 19774 FrameTime: 0.051 ms
[bump] bump-render=height: FPS: 19534 FrameTime: 0.051 ms
[effect2d] kernel=0,1,0;1,-4,1;0,1,0;: FPS: 15477 FrameTime: 0.065 ms
[effect2d] kernel=1,1,1,1,1;1,1,1,1,1;1,1,1,1,1;: FPS: 10139 FrameTime: 0.099 ms
[pulsar] light=false:quads=5:texture=false: FPS: 16858 FrameTime: 0.059 ms
[desktop] blur-radius=5:effect=blur:passes=1:separable=true:windows=4: FPS: 5961 FrameTime: 0.168 ms
[desktop] effect=shadow:windows=4: FPS: 9994 FrameTime: 0.100 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 2577 FrameTime: 0.388 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=subdata: FPS: 3585 FrameTime: 0.279 ms
[buffer] columns=200:interleave=true:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 3158 FrameTime: 0.317 ms
[ideas] speed=duration: FPS: 11924 FrameTime: 0.084 ms
[jellyfish] <default>: FPS: 12073 FrameTime: 0.083 ms
[terrain] <default>: FPS: 1350 FrameTime: 0.741 ms
[shadow] <default>: FPS: 9986 FrameTime: 0.100 ms
[refract] <default>: FPS: 2500 FrameTime: 0.400 ms
[conditionals] fragment-steps=0:vertex-steps=0: FPS: 18815 FrameTime: 0.053 ms
[conditionals] fragment-steps=5:vertex-steps=0: FPS: 18705 FrameTime: 0.053 ms
[conditionals] fragment-steps=0:vertex-steps=5: FPS: 18787 FrameTime: 0.053 ms
[function] fragment-complexity=low:fragment-steps=5: FPS: 18759 FrameTime: 0.053 ms
[function] fragment-complexity=medium:fragment-steps=5: FPS: 18691 FrameTime: 0.054 ms
[loop] fragment-loop=false:fragment-steps=5:vertex-steps=5: FPS: 18755 FrameTime: 0.053 ms
[loop] fragment-steps=5:fragment-uniform=false:vertex-steps=5: FPS: 18759 FrameTime: 0.053 ms
[loop] fragment-steps=5:fragment-uniform=true:vertex-steps=5: FPS: 18654 FrameTime: 0.054 ms
}}

==== NVIDIA GTX-1060 6GB + AMD R7 3700X @ 4.2 GHz, 8 cores, HT off ====

'''glmark2 Score: 20641'''

{{collapsible script
| type = details
| title = (click show to expand)
| lang = text
| script = ----
glmark2 2014.03+git20150611.fa71af2d
----
OpenGL Information
GL_VENDOR: NVIDIA Corporation
GL_RENDERER: GeForce GTX 1060 6GB/PCIe/SSE2
GL_VERSION: 4.6.0 NVIDIA 460.91.03
----
[build] use-vbo=false: FPS: 15192 FrameTime: 0.066 ms
[build] use-vbo=true: FPS: 30325 FrameTime: 0.033 ms
[texture] texture-filter=nearest: FPS: 27634 FrameTime: 0.036 ms
[texture] texture-filter=linear: FPS: 27511 FrameTime: 0.036 ms
[texture] texture-filter=mipmap: FPS: 28397 FrameTime: 0.035 ms
[shading] shading=gouraud: FPS: 26079 FrameTime: 0.038 ms
[shading] shading=blinn-phong-inf: FPS: 25796 FrameTime: 0.039 ms
[shading] shading=phong: FPS: 25060 FrameTime: 0.040 ms
[shading] shading=cel: FPS: 25321 FrameTime: 0.039 ms
[bump] bump-render=high-poly: FPS: 17451 FrameTime: 0.057 ms
[bump] bump-render=normals: FPS: 31963 FrameTime: 0.031 ms
[bump] bump-render=height: FPS: 31608 FrameTime: 0.032 ms
[effect2d] kernel=0,1,0;1,-4,1;0,1,0;: FPS: 20418 FrameTime: 0.049 ms
[effect2d] kernel=1,1,1,1,1;1,1,1,1,1;1,1,1,1,1;: FPS: 12585 FrameTime: 0.079 ms
[pulsar] light=false:quads=5:texture=false: FPS: 28174 FrameTime: 0.035 ms
[desktop] blur-radius=5:effect=blur:passes=1:separable=true:windows=4: FPS: 7331 FrameTime: 0.136 ms
[desktop] effect=shadow:windows=4: FPS: 14034 FrameTime: 0.071 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 2363 FrameTime: 0.423 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=subdata: FPS: 2783 FrameTime: 0.359 ms
[buffer] columns=200:interleave=true:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 2330 FrameTime: 0.429 ms
[ideas] speed=duration: FPS: 19421 FrameTime: 0.051 ms
[jellyfish] <default>: FPS: 17291 FrameTime: 0.058 ms
[terrain] <default>: FPS: 1349 FrameTime: 0.741 ms
[shadow] <default>: FPS: 15688 FrameTime: 0.064 ms
[refract] <default>: FPS: 4783 FrameTime: 0.209 ms
[conditionals] fragment-steps=0:vertex-steps=0: FPS: 28599 FrameTime: 0.035 ms
[conditionals] fragment-steps=5:vertex-steps=0: FPS: 27499 FrameTime: 0.036 ms
[conditionals] fragment-steps=0:vertex-steps=5: FPS: 28191 FrameTime: 0.035 ms
[function] fragment-complexity=low:fragment-steps=5: FPS: 27695 FrameTime: 0.036 ms
[function] fragment-complexity=medium:fragment-steps=5: FPS: 26605 FrameTime: 0.038 ms
[loop] fragment-loop=false:fragment-steps=5:vertex-steps=5: FPS: 27340 FrameTime: 0.037 ms
[loop] fragment-steps=5:fragment-uniform=false:vertex-steps=5: FPS: 27361 FrameTime: 0.037 ms
[loop] fragment-steps=5:fragment-uniform=true:vertex-steps=5: FPS: 26984 FrameTime: 0.037 ms
}}

==== NVIDIA Quadro K1000M 1GB + Intel Core i7-3610Q @ 2.3 GHz ====
Remark: during glmark2 testing CPU clock boosted to 3.3 GHz

''' glmark2 Score: 2754 '''

{{collapsible script
| type = details
| title = (click show to expand)
| lang = text
| script = ----
glmark2 2014.03+git20150611.fa71af2d
----
OpenGL Information
GL_VENDOR: NVIDIA Corporation
GL_RENDERER: Quadro K1000M/PCIe/SSE2
GL_VERSION: 4.6.0 NVIDIA 390.138
----
[build] use-vbo=false: FPS: 4154 FrameTime: 0.241 ms
[build] use-vbo=true: FPS: 4205 FrameTime: 0.238 ms
[texture] texture-filter=nearest: FPS: 3791 FrameTime: 0.264 ms
[texture] texture-filter=linear: FPS: 3718 FrameTime: 0.269 ms
[texture] texture-filter=mipmap: FPS: 3761 FrameTime: 0.266 ms
[shading] shading=gouraud: FPS: 3187 FrameTime: 0.314 ms
[shading] shading=blinn-phong-inf: FPS: 3200 FrameTime: 0.312 ms
[shading] shading=phong: FPS: 3078 FrameTime: 0.325 ms
[shading] shading=cel: FPS: 3065 FrameTime: 0.326 ms
[bump] bump-render=high-poly: FPS: 1674 FrameTime: 0.597 ms
[bump] bump-render=normals: FPS: 4329 FrameTime: 0.231 ms
[bump] bump-render=height: FPS: 4174 FrameTime: 0.240 ms
[effect2d] kernel=0,1,0;1,-4,1;0,1,0;: FPS: 2356 FrameTime: 0.424 ms
[effect2d] kernel=1,1,1,1,1;1,1,1,1,1;1,1,1,1,1;: FPS: 1249 FrameTime: 0.801 ms
[pulsar] light=false:quads=5:texture=false: FPS: 3550 FrameTime: 0.282 ms
[desktop] blur-radius=5:effect=blur:passes=1:separable=true:windows=4: FPS: 888 FrameTime: 1.126 ms
[desktop] effect=shadow:windows=4: FPS: 1453 FrameTime: 0.688 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 952 FrameTime: 1.050 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=subdata: FPS: 1277 FrameTime: 0.783 ms
[buffer] columns=200:interleave=true:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 977 FrameTime: 1.024 ms
[ideas] speed=duration: FPS: 2926 FrameTime: 0.342 ms
[jellyfish] <default>: FPS: 1551 FrameTime: 0.645 ms
[terrain] <default>: FPS: 173 FrameTime: 5.780 ms
[shadow] <default>: FPS: 2420 FrameTime: 0.413 ms
[refract] <default>: FPS: 431 FrameTime: 2.320 ms
[conditionals] fragment-steps=0:vertex-steps=0: FPS: 3776 FrameTime: 0.265 ms
[conditionals] fragment-steps=5:vertex-steps=0: FPS: 3061 FrameTime: 0.327 ms
[conditionals] fragment-steps=0:vertex-steps=5: FPS: 3776 FrameTime: 0.265 ms
[function] fragment-complexity=low:fragment-steps=5: FPS: 3775 FrameTime: 0.265 ms
[function] fragment-complexity=medium:fragment-steps=5: FPS: 3058 FrameTime: 0.327 ms
[loop] fragment-loop=false:fragment-steps=5:vertex-steps=5: FPS: 3776 FrameTime: 0.265 ms
[loop] fragment-steps=5:fragment-uniform=false:vertex-steps=5: FPS: 3776 FrameTime: 0.265 ms
[loop] fragment-steps=5:fragment-uniform=true:vertex-steps=5: FPS: 3375 FrameTime: 0.296 ms
}}

==== NVIDIA GTX 750 + Intel Core i5-2550K @ 3.4 GHz ====
Remark: no test details available.

'''glmark2 Score: 9000'''

==== NVIDIA GTX 1060 + Intel Core i5-2550K @ 3.4 GHz ====
Remark: no test details available.

'''glmark2 Score: 19000'''

OpenGL performance

2022-08-30T10:26:19Z

MariuszXC: /* AMD Tahiti XT [Radeon HD 7970 / R9 280X] + Intel Core i5-11600K @ 3.90GHz */

== OpenGL performance ==
{{See also|Profiling performance}}

OpenGL performance can be tested using glmark2 program. It is available in most Linux distributions. In Debian derived distributions (like Ubuntu) it can be installed by issuing ''sudo apt install glmark2'' from command line.

The data presented below was taken by running ''glmark2'' without any additional options, i.e. with default settings, on an otherwise idle system.

By comparing your results with measurements taken on other similar systems you can verify if your hardware and software combination is performing as expected.

=== Integrated graphics ===
==== Intel i5-4310M @ 2.70 GHz (integrated Intel HD 4600 GPU) ====

'''glmark2 Score: 1668'''

{{collapsible script
| type = details
| title = (click show to expand)
| lang = text
| script = ----
glmark2 2014.03+git20150611.fa71af2d
----
OpenGL Information
GL_VENDOR: Intel Open Source Technology Center
GL_RENDERER: Mesa DRI Intel(R) Haswell Mobile
GL_VERSION: 3.0 Mesa 18.0.5
----
<pre>
[build] use-vbo=false: FPS: 2256 FrameTime: 0.443 ms
[build] use-vbo=true: FPS: 2500 FrameTime: 0.400 ms
[texture] texture-filter=nearest: FPS: 2183 FrameTime: 0.458 ms
[texture] texture-filter=linear: FPS: 2180 FrameTime: 0.459 ms
[texture] texture-filter=mipmap: FPS: 2250 FrameTime: 0.444 ms
[shading] shading=gouraud: FPS: 2042 FrameTime: 0.490 ms
[shading] shading=blinn-phong-inf: FPS: 2049 FrameTime: 0.488 ms
[shading] shading=phong: FPS: 1938 FrameTime: 0.516 ms
[shading] shading=cel: FPS: 2037 FrameTime: 0.491 ms
[bump] bump-render=high-poly: FPS: 1701 FrameTime: 0.588 ms
[bump] bump-render=normals: FPS: 2419 FrameTime: 0.413 ms
[bump] bump-render=height: FPS: 2382 FrameTime: 0.420 ms
[effect2d] kernel=0,1,0;1,-4,1;0,1,0;: FPS: 1758 FrameTime: 0.569 ms
[effect2d] kernel=1,1,1,1,1;1,1,1,1,1;1,1,1,1,1;: FPS: 886 FrameTime: 1.129 ms
[pulsar] light=false:quads=5:texture=false: FPS: 2008 FrameTime: 0.498 ms
[desktop] blur-radius=5:effect=blur:passes=1:separable=true:windows=4: FPS: 749 FrameTime: 1.335 ms
[desktop] effect=shadow:windows=4: FPS: 1094 FrameTime: 0.914 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 770 FrameTime: 1.299 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=subdata: FPS: 655 FrameTime: 1.527 ms
[buffer] columns=200:interleave=true:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 857 FrameTime: 1.167 ms
[ideas] speed=duration: FPS: 1776 FrameTime: 0.563 ms
[jellyfish] <default>: FPS: 1275 FrameTime: 0.784 ms
[terrain] <default>: FPS: 173 FrameTime: 5.780 ms
[shadow] <default>: FPS: 805 FrameTime: 1.242 ms
[refract] <default>: FPS: 268 FrameTime: 3.731 ms
[conditionals] fragment-steps=0:vertex-steps=0: FPS: 2038 FrameTime: 0.491 ms
[conditionals] fragment-steps=5:vertex-steps=0: FPS: 2039 FrameTime: 0.490 ms
[conditionals] fragment-steps=0:vertex-steps=5: FPS: 2028 FrameTime: 0.493 ms
[function] fragment-complexity=low:fragment-steps=5: FPS: 2037 FrameTime: 0.491 ms
[function] fragment-complexity=medium:fragment-steps=5: FPS: 2051 FrameTime: 0.488 ms
[loop] fragment-loop=false:fragment-steps=5:vertex-steps=5: FPS: 1879 FrameTime: 0.532 ms
[loop] fragment-steps=5:fragment-uniform=false:vertex-steps=5: FPS: 1922 FrameTime: 0.520 ms
[loop] fragment-steps=5:fragment-uniform=true:vertex-steps=5: FPS: 2039 FrameTime: 0.490 ms</pre>
}}

==== Intel i5-6200U @ 2.3 GHz (integrated Intel UHD 620 GPU) ====
Remark: CPU clock boosted to 2.8 GHz during benchmarking

'''glmark2 Score: 1294'''

{{collapsible script
| type = details
| title = (click show to expand)
| lang = text
| script = ----
glmark2 2021.02
----
OpenGL Information
GL_VENDOR: Intel
GL_RENDERER: Mesa Intel(R) HD Graphics 520 (SKL GT2)
GL_VERSION: 4.6 (Compatibility Profile) Mesa 21.0.3
----
[build] use-vbo=false: FPS: 1500 FrameTime: 0.667 ms
[build] use-vbo=true: FPS: 1959 FrameTime: 0.510 ms
[texture] texture-filter=nearest: FPS: 1722 FrameTime: 0.581 ms
[texture] texture-filter=linear: FPS: 1736 FrameTime: 0.576 ms
[texture] texture-filter=mipmap: FPS: 1673 FrameTime: 0.598 ms
[shading] shading=gouraud: FPS: 1584 FrameTime: 0.631 ms
[shading] shading=blinn-phong-inf: FPS: 1554 FrameTime: 0.644 ms
[shading] shading=phong: FPS: 1559 FrameTime: 0.641 ms
[shading] shading=cel: FPS: 1571 FrameTime: 0.637 ms
[bump] bump-render=high-poly: FPS: 1123 FrameTime: 0.890 ms
[bump] bump-render=normals: FPS: 1945 FrameTime: 0.514 ms
[bump] bump-render=height: FPS: 1881 FrameTime: 0.532 ms
[effect2d] kernel=0,1,0;1,-4,1;0,1,0;: FPS: 1359 FrameTime: 0.736 ms
[effect2d] kernel=1,1,1,1,1;1,1,1,1,1;1,1,1,1,1;: FPS: 851 FrameTime: 1.175 ms
[pulsar] light=false:quads=5:texture=false: FPS: 1646 FrameTime: 0.608 ms
[desktop] blur-radius=5:effect=blur:passes=1:separable=true:windows=4: FPS: 757 FrameTime: 1.321 ms
[desktop] effect=shadow:windows=4: FPS: 1094 FrameTime: 0.914 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 585 FrameTime: 1.709 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=subdata: FPS: 529 FrameTime: 1.890 ms
[buffer] columns=200:interleave=true:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 669 FrameTime: 1.495 ms
[ideas] speed=duration: FPS: 1489 FrameTime: 0.672 ms
[jellyfish] <default>: FPS: 1236 FrameTime: 0.809 ms
[terrain] <default>: FPS: 188 FrameTime: 5.319 ms
[shadow] <default>: FPS: 1014 FrameTime: 0.986 ms
[refract] <default>: FPS: 356 FrameTime: 2.809 ms
[conditionals] fragment-steps=0:vertex-steps=0: FPS: 1360 FrameTime: 0.735 ms
[conditionals] fragment-steps=5:vertex-steps=0: FPS: 1407 FrameTime: 0.711 ms
[conditionals] fragment-steps=0:vertex-steps=5: FPS: 1393 FrameTime: 0.718 ms
[function] fragment-complexity=low:fragment-steps=5: FPS: 1412 FrameTime: 0.708 ms
[function] fragment-complexity=medium:fragment-steps=5: FPS: 1416 FrameTime: 0.706 ms
[loop] fragment-loop=false:fragment-steps=5:vertex-steps=5: FPS: 1369 FrameTime: 0.730 ms
[loop] fragment-steps=5:fragment-uniform=false:vertex-steps=5: FPS: 1388 FrameTime: 0.720 ms
[loop] fragment-steps=5:fragment-uniform=true:vertex-steps=5: FPS: 1383 FrameTime: 0.723 ms
}}

=== Discrete graphics card ===
Note: this section also contains hybrid configurations (e.g. laptops with dual GPU technology)

==== AMD FirePro M5950 + Intel i5-2520M ====
Remark: dual GPU technology laptop, no test details available.

'''glmark2 Score: 5600'''

==== NVIDIA RTX2060 6GB + AMD Ryzen 7 3700X 8-Core 4GHz ====
Note: one tests resulted in errors and finally a core dump.
Another test on the same hardware, with different drivers, completed.
Both test details are included.

'''glmark2 Score: 9537'''

{{collapsible script
| type = details
| title = (click show to expand)
| lang = text
| script =----
glmark2 2021.02
----
OpenGL Information
GL_VENDOR: NVIDIA Corporation
GL_RENDERER: NVIDIA GeForce RTX 2060/PCIe/SSE2
GL_VERSION: 4.6.0 NVIDIA 495.46
----
<pre>
[build] use-vbo=false: FPS: 13809 FrameTime: 0.072 ms
[build] use-vbo=true: FPS: 28367 FrameTime: 0.035 ms
[texture] texture-filter=nearest: FPS: 27958 FrameTime: 0.036 ms
[texture] texture-filter=linear: FPS: 28120 FrameTime: 0.036 ms
[texture] texture-filter=mipmap: FPS: 28036 FrameTime: 0.036 ms
[shading] shading=gouraud: FPS: 26428 FrameTime: 0.038 ms
[shading] shading=blinn-phong-inf: FPS: 26320 FrameTime: 0.038 ms
[shading] shading=phong: FPS: 25800 FrameTime: 0.039 ms
[shading] shading=cel: FPS: 25498 FrameTime: 0.039 ms
[bump] bump-render=high-poly: FPS: 20696 FrameTime: 0.048 ms
[bump] bump-render=normals: FPS: 29599 FrameTime: 0.034 ms
Error: Failed to add fragment shader from file None:
Error: 0(15) : error C0000: syntax error, unexpected identifier, expecting "::" at token "highp"
Error: 0(36) : warning C1503: undefined variable "TextureCoord"
Error: 0(37) : warning C1503: undefined variable "TextureCoord"
Error: 0(38) : warning C1503: undefined variable "TextureCoord"
Error:
[bump] bump-render=height: Set up failed
[effect2d] kernel=0,1,0;1,-4,1;0,1,0;: FPS: 22140 FrameTime: 0.045 ms
[effect2d] kernel=1,1,1,1,1;1,1,1,1,1;1,1,1,1,1;: FPS: 15018 FrameTime: 0.067 ms
[pulsar] light=false:quads=5:texture=false: FPS: 27482 FrameTime: 0.036 ms
[desktop] blur-radius=5:effect=blur:passes=1:separable=true:windows=4: FPS: 8226 FrameTime: 0.122 ms
[desktop] effect=shadow:windows=4: FPS: 10260 FrameTime: 0.097 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 1490 FrameTime: 0.671 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=subdata: FPS: 1613 FrameTime: 0.620 ms
[buffer] columns=200:interleave=true:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 2147 FrameTime: 0.466 ms
[ideas] speed=duration: FPS: 14164 FrameTime: 0.071 ms
[jellyfish] <default>: FPS: 20591 FrameTime: 0.049 ms
Error: Failed to add fragment shader from file None:
Error: 0(26) : warning C7022: unrecognized profile specifier "highp"
Error: 0(26) : error C0502: syntax error at token "highp"
Error:
Error: Failed to add fragment shader from file None:
Error: 0(75) : warning C7022: unrecognized profile specifier "highp"
Error: 0(75) : error C0502: syntax error at token "highp"
Error:
[terrain] <default>:Segmentation fault (core dumped)</pre>
}}

{{collapsible script
| type = details
| title = (click show to expand)
| lang = text
| script =----
glmark2 2021.02
----
OpenGL Information
GL_VENDOR: NVIDIA Corporation
GL_RENDERER: NVIDIA GeForce RTX 2060/PCIe/SSE2
GL_VERSION: 4.6.0 NVIDIA 515.65.01
----
<pre>
[build] use-vbo=false: FPS: 8231 FrameTime: 0.121 ms
[build] use-vbo=true: FPS: 11817 FrameTime: 0.085 ms
[texture] texture-filter=nearest: FPS: 11830 FrameTime: 0.085 ms
[texture] texture-filter=linear: FPS: 11822 FrameTime: 0.085 ms
[texture] texture-filter=mipmap: FPS: 11813 FrameTime: 0.085 ms
[shading] shading=gouraud: FPS: 11501 FrameTime: 0.087 ms
[shading] shading=blinn-phong-inf: FPS: 11429 FrameTime: 0.087 ms
[shading] shading=phong: FPS: 11334 FrameTime: 0.088 ms
[shading] shading=cel: FPS: 11262 FrameTime: 0.089 ms
[bump] bump-render=high-poly: FPS: 10097 FrameTime: 0.099 ms
[bump] bump-render=normals: FPS: 12168 FrameTime: 0.082 ms
[bump] bump-render=height: FPS: 12004 FrameTime: 0.083 ms
[effect2d] kernel=0,1,0;1,-4,1;0,1,0;: FPS: 10522 FrameTime: 0.095 ms
[effect2d] kernel=1,1,1,1,1;1,1,1,1,1;1,1,1,1,1;: FPS: 8468 FrameTime: 0.118 ms
[pulsar] light=false:quads=5:texture=false: FPS: 11776 FrameTime: 0.085 ms
[desktop] blur-radius=5:effect=blur:passes=1:separable=true:windows=4: FPS: 5667 FrameTime: 0.176 ms
[desktop] effect=shadow:windows=4: FPS: 8895 FrameTime: 0.112 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 1796 FrameTime: 0.557 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=subdata: FPS: 2017 FrameTime: 0.496 ms
[buffer] columns=200:interleave=true:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 2176 FrameTime: 0.460 ms
[ideas] speed=duration: FPS: 10641 FrameTime: 0.094 ms
[jellyfish] <default>: FPS: 10085 FrameTime: 0.099 ms
[terrain] <default>: FPS: 1323 FrameTime: 0.756 ms
[shadow] <default>: FPS: 9418 FrameTime: 0.106 ms
[refract] <default>: FPS: 4595 FrameTime: 0.218 ms
[conditionals] fragment-steps=0:vertex-steps=0: FPS: 11552 FrameTime: 0.087 ms
[conditionals] fragment-steps=5:vertex-steps=0: FPS: 11498 FrameTime: 0.087 ms
[conditionals] fragment-steps=0:vertex-steps=5: FPS: 11555 FrameTime: 0.087 ms
[function] fragment-complexity=low:fragment-steps=5: FPS: 11586 FrameTime: 0.086 ms
[function] fragment-complexity=medium:fragment-steps=5: FPS: 11454 FrameTime: 0.087 ms
[loop] fragment-loop=false:fragment-steps=5:vertex-steps=5: FPS: 11521 FrameTime: 0.087 ms
[loop] fragment-steps=5:fragment-uniform=false:vertex-steps=5: FPS: 11495 FrameTime: 0.087 ms
[loop] fragment-steps=5:fragment-uniform=true:vertex-steps=5: FPS: 11403 FrameTime: 0.088 ms</pre>
}}

==== AMD Tahiti XT [Radeon HD 7970 / R9 280X] + Intel Core i5-11600K @ 3.90GHz ====

'''glmark2 Score: 13781'''

{{collapsible script
| type = details
| title = (click show to expand)
| lang = text
| script = ----
glmark2 2021.02
----
OpenGL Information
GL_VENDOR: AMD
GL_RENDERER: AMD TAHITI (DRM 2.50.0, 5.11.0-44-generic, LLVM 12.0.0)
GL_VERSION: 4.5 (Compatibility Profile) Mesa 21.0.3
----
[build] use-vbo=false: FPS: 12290 FrameTime: 0.081 ms
[build] use-vbo=true: FPS: 19086 FrameTime: 0.052 ms
[texture] texture-filter=nearest: FPS: 18131 FrameTime: 0.055 ms
[texture] texture-filter=linear: FPS: 18165 FrameTime: 0.055 ms
[texture] texture-filter=mipmap: FPS: 18563 FrameTime: 0.054 ms
[shading] shading=gouraud: FPS: 16185 FrameTime: 0.062 ms
[shading] shading=blinn-phong-inf: FPS: 16135 FrameTime: 0.062 ms
[shading] shading=phong: FPS: 16042 FrameTime: 0.062 ms
[shading] shading=cel: FPS: 16036 FrameTime: 0.062 ms
[bump] bump-render=high-poly: FPS: 9338 FrameTime: 0.107 ms
[bump] bump-render=normals: FPS: 19774 FrameTime: 0.051 ms
[bump] bump-render=height: FPS: 19534 FrameTime: 0.051 ms
[effect2d] kernel=0,1,0;1,-4,1;0,1,0;: FPS: 15477 FrameTime: 0.065 ms
[effect2d] kernel=1,1,1,1,1;1,1,1,1,1;1,1,1,1,1;: FPS: 10139 FrameTime: 0.099 ms
[pulsar] light=false:quads=5:texture=false: FPS: 16858 FrameTime: 0.059 ms
[desktop] blur-radius=5:effect=blur:passes=1:separable=true:windows=4: FPS: 5961 FrameTime: 0.168 ms
[desktop] effect=shadow:windows=4: FPS: 9994 FrameTime: 0.100 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 2577 FrameTime: 0.388 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=subdata: FPS: 3585 FrameTime: 0.279 ms
[buffer] columns=200:interleave=true:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 3158 FrameTime: 0.317 ms
[ideas] speed=duration: FPS: 11924 FrameTime: 0.084 ms
[jellyfish] <default>: FPS: 12073 FrameTime: 0.083 ms
[terrain] <default>: FPS: 1350 FrameTime: 0.741 ms
[shadow] <default>: FPS: 9986 FrameTime: 0.100 ms
[refract] <default>: FPS: 2500 FrameTime: 0.400 ms
[conditionals] fragment-steps=0:vertex-steps=0: FPS: 18815 FrameTime: 0.053 ms
[conditionals] fragment-steps=5:vertex-steps=0: FPS: 18705 FrameTime: 0.053 ms
[conditionals] fragment-steps=0:vertex-steps=5: FPS: 18787 FrameTime: 0.053 ms
[function] fragment-complexity=low:fragment-steps=5: FPS: 18759 FrameTime: 0.053 ms
[function] fragment-complexity=medium:fragment-steps=5: FPS: 18691 FrameTime: 0.054 ms
[loop] fragment-loop=false:fragment-steps=5:vertex-steps=5: FPS: 18755 FrameTime: 0.053 ms
[loop] fragment-steps=5:fragment-uniform=false:vertex-steps=5: FPS: 18759 FrameTime: 0.053 ms
[loop] fragment-steps=5:fragment-uniform=true:vertex-steps=5: FPS: 18654 FrameTime: 0.054 ms
}}

==== NVIDIA GTX-1060 6GB + AMD R7 3700X @ 4.2 GHz, 8 cores, HT off ====

'''glmark2 Score: 20641'''

{{collapsible script
| type = details
| title = (click show to expand)
| lang = text
| script = ----
glmark2 2014.03+git20150611.fa71af2d
----
OpenGL Information
GL_VENDOR: NVIDIA Corporation
GL_RENDERER: GeForce GTX 1060 6GB/PCIe/SSE2
GL_VERSION: 4.6.0 NVIDIA 460.91.03
----
[build] use-vbo=false: FPS: 15192 FrameTime: 0.066 ms
[build] use-vbo=true: FPS: 30325 FrameTime: 0.033 ms
[texture] texture-filter=nearest: FPS: 27634 FrameTime: 0.036 ms
[texture] texture-filter=linear: FPS: 27511 FrameTime: 0.036 ms
[texture] texture-filter=mipmap: FPS: 28397 FrameTime: 0.035 ms
[shading] shading=gouraud: FPS: 26079 FrameTime: 0.038 ms
[shading] shading=blinn-phong-inf: FPS: 25796 FrameTime: 0.039 ms
[shading] shading=phong: FPS: 25060 FrameTime: 0.040 ms
[shading] shading=cel: FPS: 25321 FrameTime: 0.039 ms
[bump] bump-render=high-poly: FPS: 17451 FrameTime: 0.057 ms
[bump] bump-render=normals: FPS: 31963 FrameTime: 0.031 ms
[bump] bump-render=height: FPS: 31608 FrameTime: 0.032 ms
[effect2d] kernel=0,1,0;1,-4,1;0,1,0;: FPS: 20418 FrameTime: 0.049 ms
[effect2d] kernel=1,1,1,1,1;1,1,1,1,1;1,1,1,1,1;: FPS: 12585 FrameTime: 0.079 ms
[pulsar] light=false:quads=5:texture=false: FPS: 28174 FrameTime: 0.035 ms
[desktop] blur-radius=5:effect=blur:passes=1:separable=true:windows=4: FPS: 7331 FrameTime: 0.136 ms
[desktop] effect=shadow:windows=4: FPS: 14034 FrameTime: 0.071 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 2363 FrameTime: 0.423 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=subdata: FPS: 2783 FrameTime: 0.359 ms
[buffer] columns=200:interleave=true:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 2330 FrameTime: 0.429 ms
[ideas] speed=duration: FPS: 19421 FrameTime: 0.051 ms
[jellyfish] <default>: FPS: 17291 FrameTime: 0.058 ms
[terrain] <default>: FPS: 1349 FrameTime: 0.741 ms
[shadow] <default>: FPS: 15688 FrameTime: 0.064 ms
[refract] <default>: FPS: 4783 FrameTime: 0.209 ms
[conditionals] fragment-steps=0:vertex-steps=0: FPS: 28599 FrameTime: 0.035 ms
[conditionals] fragment-steps=5:vertex-steps=0: FPS: 27499 FrameTime: 0.036 ms
[conditionals] fragment-steps=0:vertex-steps=5: FPS: 28191 FrameTime: 0.035 ms
[function] fragment-complexity=low:fragment-steps=5: FPS: 27695 FrameTime: 0.036 ms
[function] fragment-complexity=medium:fragment-steps=5: FPS: 26605 FrameTime: 0.038 ms
[loop] fragment-loop=false:fragment-steps=5:vertex-steps=5: FPS: 27340 FrameTime: 0.037 ms
[loop] fragment-steps=5:fragment-uniform=false:vertex-steps=5: FPS: 27361 FrameTime: 0.037 ms
[loop] fragment-steps=5:fragment-uniform=true:vertex-steps=5: FPS: 26984 FrameTime: 0.037 ms
}}

==== NVIDIA Quadro K1000M 1GB + Intel Core i7-3610Q @ 2.3 GHz ====
Remark: during glmark2 testing CPU clock boosted to 3.3 GHz

''' glmark2 Score: 2754 '''

{{collapsible script
| type = details
| title = (click show to expand)
| lang = text
| script = ----
glmark2 2014.03+git20150611.fa71af2d
----
OpenGL Information
GL_VENDOR: NVIDIA Corporation
GL_RENDERER: Quadro K1000M/PCIe/SSE2
GL_VERSION: 4.6.0 NVIDIA 390.138
----
[build] use-vbo=false: FPS: 4154 FrameTime: 0.241 ms
[build] use-vbo=true: FPS: 4205 FrameTime: 0.238 ms
[texture] texture-filter=nearest: FPS: 3791 FrameTime: 0.264 ms
[texture] texture-filter=linear: FPS: 3718 FrameTime: 0.269 ms
[texture] texture-filter=mipmap: FPS: 3761 FrameTime: 0.266 ms
[shading] shading=gouraud: FPS: 3187 FrameTime: 0.314 ms
[shading] shading=blinn-phong-inf: FPS: 3200 FrameTime: 0.312 ms
[shading] shading=phong: FPS: 3078 FrameTime: 0.325 ms
[shading] shading=cel: FPS: 3065 FrameTime: 0.326 ms
[bump] bump-render=high-poly: FPS: 1674 FrameTime: 0.597 ms
[bump] bump-render=normals: FPS: 4329 FrameTime: 0.231 ms
[bump] bump-render=height: FPS: 4174 FrameTime: 0.240 ms
[effect2d] kernel=0,1,0;1,-4,1;0,1,0;: FPS: 2356 FrameTime: 0.424 ms
[effect2d] kernel=1,1,1,1,1;1,1,1,1,1;1,1,1,1,1;: FPS: 1249 FrameTime: 0.801 ms
[pulsar] light=false:quads=5:texture=false: FPS: 3550 FrameTime: 0.282 ms
[desktop] blur-radius=5:effect=blur:passes=1:separable=true:windows=4: FPS: 888 FrameTime: 1.126 ms
[desktop] effect=shadow:windows=4: FPS: 1453 FrameTime: 0.688 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 952 FrameTime: 1.050 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=subdata: FPS: 1277 FrameTime: 0.783 ms
[buffer] columns=200:interleave=true:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 977 FrameTime: 1.024 ms
[ideas] speed=duration: FPS: 2926 FrameTime: 0.342 ms
[jellyfish] <default>: FPS: 1551 FrameTime: 0.645 ms
[terrain] <default>: FPS: 173 FrameTime: 5.780 ms
[shadow] <default>: FPS: 2420 FrameTime: 0.413 ms
[refract] <default>: FPS: 431 FrameTime: 2.320 ms
[conditionals] fragment-steps=0:vertex-steps=0: FPS: 3776 FrameTime: 0.265 ms
[conditionals] fragment-steps=5:vertex-steps=0: FPS: 3061 FrameTime: 0.327 ms
[conditionals] fragment-steps=0:vertex-steps=5: FPS: 3776 FrameTime: 0.265 ms
[function] fragment-complexity=low:fragment-steps=5: FPS: 3775 FrameTime: 0.265 ms
[function] fragment-complexity=medium:fragment-steps=5: FPS: 3058 FrameTime: 0.327 ms
[loop] fragment-loop=false:fragment-steps=5:vertex-steps=5: FPS: 3776 FrameTime: 0.265 ms
[loop] fragment-steps=5:fragment-uniform=false:vertex-steps=5: FPS: 3776 FrameTime: 0.265 ms
[loop] fragment-steps=5:fragment-uniform=true:vertex-steps=5: FPS: 3375 FrameTime: 0.296 ms
}}

==== NVIDIA GTX 750 + Intel Core i5-2550K @ 3.4 GHz ====
Remark: no test details available.

'''glmark2 Score: 9000'''

==== NVIDIA GTX 1060 + Intel Core i5-2550K @ 3.4 GHz ====
Remark: no test details available.

'''glmark2 Score: 19000'''

OpenGL performance

2022-08-30T10:25:56Z

MariuszXC: /* NVIDIA RTX2060 6GB + AMD Ryzen 7 3700X 8-Core 4GHz */

== OpenGL performance ==
{{See also|Profiling performance}}

OpenGL performance can be tested using glmark2 program. It is available in most Linux distributions. In Debian derived distributions (like Ubuntu) it can be installed by issuing ''sudo apt install glmark2'' from command line.

The data presented below was taken by running ''glmark2'' without any additional options, i.e. with default settings, on an otherwise idle system.

By comparing your results with measurements taken on other similar systems you can verify if your hardware and software combination is performing as expected.

=== Integrated graphics ===
==== Intel i5-4310M @ 2.70 GHz (integrated Intel HD 4600 GPU) ====

'''glmark2 Score: 1668'''

{{collapsible script
| type = details
| title = (click show to expand)
| lang = text
| script = ----
glmark2 2014.03+git20150611.fa71af2d
----
OpenGL Information
GL_VENDOR: Intel Open Source Technology Center
GL_RENDERER: Mesa DRI Intel(R) Haswell Mobile
GL_VERSION: 3.0 Mesa 18.0.5
----
<pre>
[build] use-vbo=false: FPS: 2256 FrameTime: 0.443 ms
[build] use-vbo=true: FPS: 2500 FrameTime: 0.400 ms
[texture] texture-filter=nearest: FPS: 2183 FrameTime: 0.458 ms
[texture] texture-filter=linear: FPS: 2180 FrameTime: 0.459 ms
[texture] texture-filter=mipmap: FPS: 2250 FrameTime: 0.444 ms
[shading] shading=gouraud: FPS: 2042 FrameTime: 0.490 ms
[shading] shading=blinn-phong-inf: FPS: 2049 FrameTime: 0.488 ms
[shading] shading=phong: FPS: 1938 FrameTime: 0.516 ms
[shading] shading=cel: FPS: 2037 FrameTime: 0.491 ms
[bump] bump-render=high-poly: FPS: 1701 FrameTime: 0.588 ms
[bump] bump-render=normals: FPS: 2419 FrameTime: 0.413 ms
[bump] bump-render=height: FPS: 2382 FrameTime: 0.420 ms
[effect2d] kernel=0,1,0;1,-4,1;0,1,0;: FPS: 1758 FrameTime: 0.569 ms
[effect2d] kernel=1,1,1,1,1;1,1,1,1,1;1,1,1,1,1;: FPS: 886 FrameTime: 1.129 ms
[pulsar] light=false:quads=5:texture=false: FPS: 2008 FrameTime: 0.498 ms
[desktop] blur-radius=5:effect=blur:passes=1:separable=true:windows=4: FPS: 749 FrameTime: 1.335 ms
[desktop] effect=shadow:windows=4: FPS: 1094 FrameTime: 0.914 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 770 FrameTime: 1.299 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=subdata: FPS: 655 FrameTime: 1.527 ms
[buffer] columns=200:interleave=true:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 857 FrameTime: 1.167 ms
[ideas] speed=duration: FPS: 1776 FrameTime: 0.563 ms
[jellyfish] <default>: FPS: 1275 FrameTime: 0.784 ms
[terrain] <default>: FPS: 173 FrameTime: 5.780 ms
[shadow] <default>: FPS: 805 FrameTime: 1.242 ms
[refract] <default>: FPS: 268 FrameTime: 3.731 ms
[conditionals] fragment-steps=0:vertex-steps=0: FPS: 2038 FrameTime: 0.491 ms
[conditionals] fragment-steps=5:vertex-steps=0: FPS: 2039 FrameTime: 0.490 ms
[conditionals] fragment-steps=0:vertex-steps=5: FPS: 2028 FrameTime: 0.493 ms
[function] fragment-complexity=low:fragment-steps=5: FPS: 2037 FrameTime: 0.491 ms
[function] fragment-complexity=medium:fragment-steps=5: FPS: 2051 FrameTime: 0.488 ms
[loop] fragment-loop=false:fragment-steps=5:vertex-steps=5: FPS: 1879 FrameTime: 0.532 ms
[loop] fragment-steps=5:fragment-uniform=false:vertex-steps=5: FPS: 1922 FrameTime: 0.520 ms
[loop] fragment-steps=5:fragment-uniform=true:vertex-steps=5: FPS: 2039 FrameTime: 0.490 ms</pre>
}}

==== Intel i5-6200U @ 2.3 GHz (integrated Intel UHD 620 GPU) ====
Remark: CPU clock boosted to 2.8 GHz during benchmarking

'''glmark2 Score: 1294'''

{{collapsible script
| type = details
| title = (click show to expand)
| lang = text
| script = ----
glmark2 2021.02
----
OpenGL Information
GL_VENDOR: Intel
GL_RENDERER: Mesa Intel(R) HD Graphics 520 (SKL GT2)
GL_VERSION: 4.6 (Compatibility Profile) Mesa 21.0.3
----
[build] use-vbo=false: FPS: 1500 FrameTime: 0.667 ms
[build] use-vbo=true: FPS: 1959 FrameTime: 0.510 ms
[texture] texture-filter=nearest: FPS: 1722 FrameTime: 0.581 ms
[texture] texture-filter=linear: FPS: 1736 FrameTime: 0.576 ms
[texture] texture-filter=mipmap: FPS: 1673 FrameTime: 0.598 ms
[shading] shading=gouraud: FPS: 1584 FrameTime: 0.631 ms
[shading] shading=blinn-phong-inf: FPS: 1554 FrameTime: 0.644 ms
[shading] shading=phong: FPS: 1559 FrameTime: 0.641 ms
[shading] shading=cel: FPS: 1571 FrameTime: 0.637 ms
[bump] bump-render=high-poly: FPS: 1123 FrameTime: 0.890 ms
[bump] bump-render=normals: FPS: 1945 FrameTime: 0.514 ms
[bump] bump-render=height: FPS: 1881 FrameTime: 0.532 ms
[effect2d] kernel=0,1,0;1,-4,1;0,1,0;: FPS: 1359 FrameTime: 0.736 ms
[effect2d] kernel=1,1,1,1,1;1,1,1,1,1;1,1,1,1,1;: FPS: 851 FrameTime: 1.175 ms
[pulsar] light=false:quads=5:texture=false: FPS: 1646 FrameTime: 0.608 ms
[desktop] blur-radius=5:effect=blur:passes=1:separable=true:windows=4: FPS: 757 FrameTime: 1.321 ms
[desktop] effect=shadow:windows=4: FPS: 1094 FrameTime: 0.914 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 585 FrameTime: 1.709 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=subdata: FPS: 529 FrameTime: 1.890 ms
[buffer] columns=200:interleave=true:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 669 FrameTime: 1.495 ms
[ideas] speed=duration: FPS: 1489 FrameTime: 0.672 ms
[jellyfish] <default>: FPS: 1236 FrameTime: 0.809 ms
[terrain] <default>: FPS: 188 FrameTime: 5.319 ms
[shadow] <default>: FPS: 1014 FrameTime: 0.986 ms
[refract] <default>: FPS: 356 FrameTime: 2.809 ms
[conditionals] fragment-steps=0:vertex-steps=0: FPS: 1360 FrameTime: 0.735 ms
[conditionals] fragment-steps=5:vertex-steps=0: FPS: 1407 FrameTime: 0.711 ms
[conditionals] fragment-steps=0:vertex-steps=5: FPS: 1393 FrameTime: 0.718 ms
[function] fragment-complexity=low:fragment-steps=5: FPS: 1412 FrameTime: 0.708 ms
[function] fragment-complexity=medium:fragment-steps=5: FPS: 1416 FrameTime: 0.706 ms
[loop] fragment-loop=false:fragment-steps=5:vertex-steps=5: FPS: 1369 FrameTime: 0.730 ms
[loop] fragment-steps=5:fragment-uniform=false:vertex-steps=5: FPS: 1388 FrameTime: 0.720 ms
[loop] fragment-steps=5:fragment-uniform=true:vertex-steps=5: FPS: 1383 FrameTime: 0.723 ms
}}

=== Discrete graphics card ===
Note: this section also contains hybrid configurations (e.g. laptops with dual GPU technology)

==== AMD FirePro M5950 + Intel i5-2520M ====
Remark: dual GPU technology laptop, no test details available.

'''glmark2 Score: 5600'''

==== NVIDIA RTX2060 6GB + AMD Ryzen 7 3700X 8-Core 4GHz ====
Note: one tests resulted in errors and finally a core dump.
Another test on the same hardware, with different drivers, completed.
Both test details are included.

'''glmark2 Score: 9537'''

{{collapsible script
| type = details
| title = (click show to expand)
| lang = text
| script =----
glmark2 2021.02
----
OpenGL Information
GL_VENDOR: NVIDIA Corporation
GL_RENDERER: NVIDIA GeForce RTX 2060/PCIe/SSE2
GL_VERSION: 4.6.0 NVIDIA 495.46
----
<pre>
[build] use-vbo=false: FPS: 13809 FrameTime: 0.072 ms
[build] use-vbo=true: FPS: 28367 FrameTime: 0.035 ms
[texture] texture-filter=nearest: FPS: 27958 FrameTime: 0.036 ms
[texture] texture-filter=linear: FPS: 28120 FrameTime: 0.036 ms
[texture] texture-filter=mipmap: FPS: 28036 FrameTime: 0.036 ms
[shading] shading=gouraud: FPS: 26428 FrameTime: 0.038 ms
[shading] shading=blinn-phong-inf: FPS: 26320 FrameTime: 0.038 ms
[shading] shading=phong: FPS: 25800 FrameTime: 0.039 ms
[shading] shading=cel: FPS: 25498 FrameTime: 0.039 ms
[bump] bump-render=high-poly: FPS: 20696 FrameTime: 0.048 ms
[bump] bump-render=normals: FPS: 29599 FrameTime: 0.034 ms
Error: Failed to add fragment shader from file None:
Error: 0(15) : error C0000: syntax error, unexpected identifier, expecting "::" at token "highp"
Error: 0(36) : warning C1503: undefined variable "TextureCoord"
Error: 0(37) : warning C1503: undefined variable "TextureCoord"
Error: 0(38) : warning C1503: undefined variable "TextureCoord"
Error:
[bump] bump-render=height: Set up failed
[effect2d] kernel=0,1,0;1,-4,1;0,1,0;: FPS: 22140 FrameTime: 0.045 ms
[effect2d] kernel=1,1,1,1,1;1,1,1,1,1;1,1,1,1,1;: FPS: 15018 FrameTime: 0.067 ms
[pulsar] light=false:quads=5:texture=false: FPS: 27482 FrameTime: 0.036 ms
[desktop] blur-radius=5:effect=blur:passes=1:separable=true:windows=4: FPS: 8226 FrameTime: 0.122 ms
[desktop] effect=shadow:windows=4: FPS: 10260 FrameTime: 0.097 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 1490 FrameTime: 0.671 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=subdata: FPS: 1613 FrameTime: 0.620 ms
[buffer] columns=200:interleave=true:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 2147 FrameTime: 0.466 ms
[ideas] speed=duration: FPS: 14164 FrameTime: 0.071 ms
[jellyfish] <default>: FPS: 20591 FrameTime: 0.049 ms
Error: Failed to add fragment shader from file None:
Error: 0(26) : warning C7022: unrecognized profile specifier "highp"
Error: 0(26) : error C0502: syntax error at token "highp"
Error:
Error: Failed to add fragment shader from file None:
Error: 0(75) : warning C7022: unrecognized profile specifier "highp"
Error: 0(75) : error C0502: syntax error at token "highp"
Error:
[terrain] <default>:Segmentation fault (core dumped)</pre>
}}

{{collapsible script
| type = details
| title = (click show to expand)
| lang = text
| script =----
glmark2 2021.02
----
OpenGL Information
GL_VENDOR: NVIDIA Corporation
GL_RENDERER: NVIDIA GeForce RTX 2060/PCIe/SSE2
GL_VERSION: 4.6.0 NVIDIA 515.65.01
----
<pre>
[build] use-vbo=false: FPS: 8231 FrameTime: 0.121 ms
[build] use-vbo=true: FPS: 11817 FrameTime: 0.085 ms
[texture] texture-filter=nearest: FPS: 11830 FrameTime: 0.085 ms
[texture] texture-filter=linear: FPS: 11822 FrameTime: 0.085 ms
[texture] texture-filter=mipmap: FPS: 11813 FrameTime: 0.085 ms
[shading] shading=gouraud: FPS: 11501 FrameTime: 0.087 ms
[shading] shading=blinn-phong-inf: FPS: 11429 FrameTime: 0.087 ms
[shading] shading=phong: FPS: 11334 FrameTime: 0.088 ms
[shading] shading=cel: FPS: 11262 FrameTime: 0.089 ms
[bump] bump-render=high-poly: FPS: 10097 FrameTime: 0.099 ms
[bump] bump-render=normals: FPS: 12168 FrameTime: 0.082 ms
[bump] bump-render=height: FPS: 12004 FrameTime: 0.083 ms
[effect2d] kernel=0,1,0;1,-4,1;0,1,0;: FPS: 10522 FrameTime: 0.095 ms
[effect2d] kernel=1,1,1,1,1;1,1,1,1,1;1,1,1,1,1;: FPS: 8468 FrameTime: 0.118 ms
[pulsar] light=false:quads=5:texture=false: FPS: 11776 FrameTime: 0.085 ms
[desktop] blur-radius=5:effect=blur:passes=1:separable=true:windows=4: FPS: 5667 FrameTime: 0.176 ms
[desktop] effect=shadow:windows=4: FPS: 8895 FrameTime: 0.112 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 1796 FrameTime: 0.557 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=subdata: FPS: 2017 FrameTime: 0.496 ms
[buffer] columns=200:interleave=true:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 2176 FrameTime: 0.460 ms
[ideas] speed=duration: FPS: 10641 FrameTime: 0.094 ms
[jellyfish] <default>: FPS: 10085 FrameTime: 0.099 ms
[terrain] <default>: FPS: 1323 FrameTime: 0.756 ms
[shadow] <default>: FPS: 9418 FrameTime: 0.106 ms
[refract] <default>: FPS: 4595 FrameTime: 0.218 ms
[conditionals] fragment-steps=0:vertex-steps=0: FPS: 11552 FrameTime: 0.087 ms
[conditionals] fragment-steps=5:vertex-steps=0: FPS: 11498 FrameTime: 0.087 ms
[conditionals] fragment-steps=0:vertex-steps=5: FPS: 11555 FrameTime: 0.087 ms
[function] fragment-complexity=low:fragment-steps=5: FPS: 11586 FrameTime: 0.086 ms
[function] fragment-complexity=medium:fragment-steps=5: FPS: 11454 FrameTime: 0.087 ms
[loop] fragment-loop=false:fragment-steps=5:vertex-steps=5: FPS: 11521 FrameTime: 0.087 ms
[loop] fragment-steps=5:fragment-uniform=false:vertex-steps=5: FPS: 11495 FrameTime: 0.087 ms
[loop] fragment-steps=5:fragment-uniform=true:vertex-steps=5: FPS: 11403 FrameTime: 0.088 ms</pre>
}}

==== AMD Tahiti XT [Radeon HD 7970 / R9 280X] + Intel Core i5-11600K @ 3.90GHz ====

'''glmark2 Score: 13781'''

{{collapsible script
| type = details
| title = (click show to expand)
| lang = text
| script = ----
glmark2 2021.02
----
OpenGL Information
GL_VENDOR: AMD
GL_RENDERER: AMD TAHITI (DRM 2.50.0, 5.11.0-44-generic, LLVM 12.0.0)
GL_VERSION: 4.5 (Compatibility Profile) Mesa 21.0.3
----
[build] use-vbo=false: FPS: 12290 FrameTime: 0.081 ms
[build] use-vbo=true: FPS: 19086 FrameTime: 0.052 ms
[texture] texture-filter=nearest: FPS: 18131 FrameTime: 0.055 ms
[texture] texture-filter=linear: FPS: 18165 FrameTime: 0.055 ms
[texture] texture-filter=mipmap: FPS: 18563 FrameTime: 0.054 ms
[shading] shading=gouraud: FPS: 16185 FrameTime: 0.062 ms
[shading] shading=blinn-phong-inf: FPS: 16135 FrameTime: 0.062 ms
[shading] shading=phong: FPS: 16042 FrameTime: 0.062 ms
[shading] shading=cel: FPS: 16036 FrameTime: 0.062 ms
[bump] bump-render=high-poly: FPS: 9338 FrameTime: 0.107 ms
[bump] bump-render=normals: FPS: 19774 FrameTime: 0.051 ms
[bump] bump-render=height: FPS: 19534 FrameTime: 0.051 ms
[effect2d] kernel=0,1,0;1,-4,1;0,1,0;: FPS: 15477 FrameTime: 0.065 ms
[effect2d] kernel=1,1,1,1,1;1,1,1,1,1;1,1,1,1,1;: FPS: 10139 FrameTime: 0.099 ms
[pulsar] light=false:quads=5:texture=false: FPS: 16858 FrameTime: 0.059 ms
[desktop] blur-radius=5:effect=blur:passes=1:separable=true:windows=4: FPS: 5961 FrameTime: 0.168 ms
[desktop] effect=shadow:windows=4: FPS: 9994 FrameTime: 0.100 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 2577 FrameTime: 0.388 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=subdata: FPS: 3585 FrameTime: 0.279 ms
[buffer] columns=200:interleave=true:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 3158 FrameTime: 0.317 ms
[ideas] speed=duration: FPS: 11924 FrameTime: 0.084 ms
[jellyfish] <default>: FPS: 12073 FrameTime: 0.083 ms
[terrain] <default>: FPS: 1350 FrameTime: 0.741 ms
[shadow] <default>: FPS: 9986 FrameTime: 0.100 ms
[refract] <default>: FPS: 2500 FrameTime: 0.400 ms
[conditionals] fragment-steps=0:vertex-steps=0: FPS: 18815 FrameTime: 0.053 ms
[conditionals] fragment-steps=5:vertex-steps=0: FPS: 18705 FrameTime: 0.053 ms
[conditionals] fragment-steps=0:vertex-steps=5: FPS: 18787 FrameTime: 0.053 ms
[function] fragment-complexity=low:fragment-steps=5: FPS: 18759 FrameTime: 0.053 ms
[function] fragment-complexity=medium:fragment-steps=5: FPS: 18691 FrameTime: 0.054 ms
[loop] fragment-loop=false:fragment-steps=5:vertex-steps=5: FPS: 18755 FrameTime: 0.053 ms
[loop] fragment-steps=5:fragment-uniform=false:vertex-steps=5: FPS: 18759 FrameTime: 0.053 ms
[loop] fragment-steps=5:fragment-uniform=true:vertex-steps=5: FPS: 18654 FrameTime: 0.054 ms
}}

==== NVIDIA GTX-1060 6GB + AMD R7 3700X @ 4.2 GHz, 8 cores, HT off ====

'''glmark2 Score: 20641'''

{{collapsible script
| type = details
| title = (click show to expand)
| lang = text
| script = ----
glmark2 2014.03+git20150611.fa71af2d
----
OpenGL Information
GL_VENDOR: NVIDIA Corporation
GL_RENDERER: GeForce GTX 1060 6GB/PCIe/SSE2
GL_VERSION: 4.6.0 NVIDIA 460.91.03
----
[build] use-vbo=false: FPS: 15192 FrameTime: 0.066 ms
[build] use-vbo=true: FPS: 30325 FrameTime: 0.033 ms
[texture] texture-filter=nearest: FPS: 27634 FrameTime: 0.036 ms
[texture] texture-filter=linear: FPS: 27511 FrameTime: 0.036 ms
[texture] texture-filter=mipmap: FPS: 28397 FrameTime: 0.035 ms
[shading] shading=gouraud: FPS: 26079 FrameTime: 0.038 ms
[shading] shading=blinn-phong-inf: FPS: 25796 FrameTime: 0.039 ms
[shading] shading=phong: FPS: 25060 FrameTime: 0.040 ms
[shading] shading=cel: FPS: 25321 FrameTime: 0.039 ms
[bump] bump-render=high-poly: FPS: 17451 FrameTime: 0.057 ms
[bump] bump-render=normals: FPS: 31963 FrameTime: 0.031 ms
[bump] bump-render=height: FPS: 31608 FrameTime: 0.032 ms
[effect2d] kernel=0,1,0;1,-4,1;0,1,0;: FPS: 20418 FrameTime: 0.049 ms
[effect2d] kernel=1,1,1,1,1;1,1,1,1,1;1,1,1,1,1;: FPS: 12585 FrameTime: 0.079 ms
[pulsar] light=false:quads=5:texture=false: FPS: 28174 FrameTime: 0.035 ms
[desktop] blur-radius=5:effect=blur:passes=1:separable=true:windows=4: FPS: 7331 FrameTime: 0.136 ms
[desktop] effect=shadow:windows=4: FPS: 14034 FrameTime: 0.071 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 2363 FrameTime: 0.423 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=subdata: FPS: 2783 FrameTime: 0.359 ms
[buffer] columns=200:interleave=true:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 2330 FrameTime: 0.429 ms
[ideas] speed=duration: FPS: 19421 FrameTime: 0.051 ms
[jellyfish] <default>: FPS: 17291 FrameTime: 0.058 ms
[terrain] <default>: FPS: 1349 FrameTime: 0.741 ms
[shadow] <default>: FPS: 15688 FrameTime: 0.064 ms
[refract] <default>: FPS: 4783 FrameTime: 0.209 ms
[conditionals] fragment-steps=0:vertex-steps=0: FPS: 28599 FrameTime: 0.035 ms
[conditionals] fragment-steps=5:vertex-steps=0: FPS: 27499 FrameTime: 0.036 ms
[conditionals] fragment-steps=0:vertex-steps=5: FPS: 28191 FrameTime: 0.035 ms
[function] fragment-complexity=low:fragment-steps=5: FPS: 27695 FrameTime: 0.036 ms
[function] fragment-complexity=medium:fragment-steps=5: FPS: 26605 FrameTime: 0.038 ms
[loop] fragment-loop=false:fragment-steps=5:vertex-steps=5: FPS: 27340 FrameTime: 0.037 ms
[loop] fragment-steps=5:fragment-uniform=false:vertex-steps=5: FPS: 27361 FrameTime: 0.037 ms
[loop] fragment-steps=5:fragment-uniform=true:vertex-steps=5: FPS: 26984 FrameTime: 0.037 ms
}}

==== NVIDIA Quadro K1000M 1GB + Intel Core i7-3610Q @ 2.3 GHz ====
Remark: during glmark2 testing CPU clock boosted to 3.3 GHz

''' glmark2 Score: 2754 '''

{{collapsible script
| type = details
| title = (click show to expand)
| lang = text
| script = ----
glmark2 2014.03+git20150611.fa71af2d
----
OpenGL Information
GL_VENDOR: NVIDIA Corporation
GL_RENDERER: Quadro K1000M/PCIe/SSE2
GL_VERSION: 4.6.0 NVIDIA 390.138
----
[build] use-vbo=false: FPS: 4154 FrameTime: 0.241 ms
[build] use-vbo=true: FPS: 4205 FrameTime: 0.238 ms
[texture] texture-filter=nearest: FPS: 3791 FrameTime: 0.264 ms
[texture] texture-filter=linear: FPS: 3718 FrameTime: 0.269 ms
[texture] texture-filter=mipmap: FPS: 3761 FrameTime: 0.266 ms
[shading] shading=gouraud: FPS: 3187 FrameTime: 0.314 ms
[shading] shading=blinn-phong-inf: FPS: 3200 FrameTime: 0.312 ms
[shading] shading=phong: FPS: 3078 FrameTime: 0.325 ms
[shading] shading=cel: FPS: 3065 FrameTime: 0.326 ms
[bump] bump-render=high-poly: FPS: 1674 FrameTime: 0.597 ms
[bump] bump-render=normals: FPS: 4329 FrameTime: 0.231 ms
[bump] bump-render=height: FPS: 4174 FrameTime: 0.240 ms
[effect2d] kernel=0,1,0;1,-4,1;0,1,0;: FPS: 2356 FrameTime: 0.424 ms
[effect2d] kernel=1,1,1,1,1;1,1,1,1,1;1,1,1,1,1;: FPS: 1249 FrameTime: 0.801 ms
[pulsar] light=false:quads=5:texture=false: FPS: 3550 FrameTime: 0.282 ms
[desktop] blur-radius=5:effect=blur:passes=1:separable=true:windows=4: FPS: 888 FrameTime: 1.126 ms
[desktop] effect=shadow:windows=4: FPS: 1453 FrameTime: 0.688 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 952 FrameTime: 1.050 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=subdata: FPS: 1277 FrameTime: 0.783 ms
[buffer] columns=200:interleave=true:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 977 FrameTime: 1.024 ms
[ideas] speed=duration: FPS: 2926 FrameTime: 0.342 ms
[jellyfish] <default>: FPS: 1551 FrameTime: 0.645 ms
[terrain] <default>: FPS: 173 FrameTime: 5.780 ms
[shadow] <default>: FPS: 2420 FrameTime: 0.413 ms
[refract] <default>: FPS: 431 FrameTime: 2.320 ms
[conditionals] fragment-steps=0:vertex-steps=0: FPS: 3776 FrameTime: 0.265 ms
[conditionals] fragment-steps=5:vertex-steps=0: FPS: 3061 FrameTime: 0.327 ms
[conditionals] fragment-steps=0:vertex-steps=5: FPS: 3776 FrameTime: 0.265 ms
[function] fragment-complexity=low:fragment-steps=5: FPS: 3775 FrameTime: 0.265 ms
[function] fragment-complexity=medium:fragment-steps=5: FPS: 3058 FrameTime: 0.327 ms
[loop] fragment-loop=false:fragment-steps=5:vertex-steps=5: FPS: 3776 FrameTime: 0.265 ms
[loop] fragment-steps=5:fragment-uniform=false:vertex-steps=5: FPS: 3776 FrameTime: 0.265 ms
[loop] fragment-steps=5:fragment-uniform=true:vertex-steps=5: FPS: 3375 FrameTime: 0.296 ms
}}

==== NVIDIA GTX 750 + Intel Core i5-2550K @ 3.4 GHz ====
Remark: no test details available.

'''glmark2 Score: 9000'''

==== NVIDIA GTX 1060 + Intel Core i5-2550K @ 3.4 GHz ====
Remark: no test details available.

'''glmark2 Score: 19000'''

OpenGL performance

2022-08-30T10:24:50Z

MariuszXC: /* NVIDIA RTX2060 6GB + AMD Ryzen 7 3700X 8-Core 4GHz */

== OpenGL performance ==
{{See also|Profiling performance}}

OpenGL performance can be tested using glmark2 program. It is available in most Linux distributions. In Debian derived distributions (like Ubuntu) it can be installed by issuing ''sudo apt install glmark2'' from command line.

The data presented below was taken by running ''glmark2'' without any additional options, i.e. with default settings, on an otherwise idle system.

By comparing your results with measurements taken on other similar systems you can verify if your hardware and software combination is performing as expected.

=== Integrated graphics ===
==== Intel i5-4310M @ 2.70 GHz (integrated Intel HD 4600 GPU) ====

'''glmark2 Score: 1668'''

{{collapsible script
| type = details
| title = (click show to expand)
| lang = text
| script = ----
glmark2 2014.03+git20150611.fa71af2d
----
OpenGL Information
GL_VENDOR: Intel Open Source Technology Center
GL_RENDERER: Mesa DRI Intel(R) Haswell Mobile
GL_VERSION: 3.0 Mesa 18.0.5
----
<pre>
[build] use-vbo=false: FPS: 2256 FrameTime: 0.443 ms
[build] use-vbo=true: FPS: 2500 FrameTime: 0.400 ms
[texture] texture-filter=nearest: FPS: 2183 FrameTime: 0.458 ms
[texture] texture-filter=linear: FPS: 2180 FrameTime: 0.459 ms
[texture] texture-filter=mipmap: FPS: 2250 FrameTime: 0.444 ms
[shading] shading=gouraud: FPS: 2042 FrameTime: 0.490 ms
[shading] shading=blinn-phong-inf: FPS: 2049 FrameTime: 0.488 ms
[shading] shading=phong: FPS: 1938 FrameTime: 0.516 ms
[shading] shading=cel: FPS: 2037 FrameTime: 0.491 ms
[bump] bump-render=high-poly: FPS: 1701 FrameTime: 0.588 ms
[bump] bump-render=normals: FPS: 2419 FrameTime: 0.413 ms
[bump] bump-render=height: FPS: 2382 FrameTime: 0.420 ms
[effect2d] kernel=0,1,0;1,-4,1;0,1,0;: FPS: 1758 FrameTime: 0.569 ms
[effect2d] kernel=1,1,1,1,1;1,1,1,1,1;1,1,1,1,1;: FPS: 886 FrameTime: 1.129 ms
[pulsar] light=false:quads=5:texture=false: FPS: 2008 FrameTime: 0.498 ms
[desktop] blur-radius=5:effect=blur:passes=1:separable=true:windows=4: FPS: 749 FrameTime: 1.335 ms
[desktop] effect=shadow:windows=4: FPS: 1094 FrameTime: 0.914 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 770 FrameTime: 1.299 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=subdata: FPS: 655 FrameTime: 1.527 ms
[buffer] columns=200:interleave=true:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 857 FrameTime: 1.167 ms
[ideas] speed=duration: FPS: 1776 FrameTime: 0.563 ms
[jellyfish] <default>: FPS: 1275 FrameTime: 0.784 ms
[terrain] <default>: FPS: 173 FrameTime: 5.780 ms
[shadow] <default>: FPS: 805 FrameTime: 1.242 ms
[refract] <default>: FPS: 268 FrameTime: 3.731 ms
[conditionals] fragment-steps=0:vertex-steps=0: FPS: 2038 FrameTime: 0.491 ms
[conditionals] fragment-steps=5:vertex-steps=0: FPS: 2039 FrameTime: 0.490 ms
[conditionals] fragment-steps=0:vertex-steps=5: FPS: 2028 FrameTime: 0.493 ms
[function] fragment-complexity=low:fragment-steps=5: FPS: 2037 FrameTime: 0.491 ms
[function] fragment-complexity=medium:fragment-steps=5: FPS: 2051 FrameTime: 0.488 ms
[loop] fragment-loop=false:fragment-steps=5:vertex-steps=5: FPS: 1879 FrameTime: 0.532 ms
[loop] fragment-steps=5:fragment-uniform=false:vertex-steps=5: FPS: 1922 FrameTime: 0.520 ms
[loop] fragment-steps=5:fragment-uniform=true:vertex-steps=5: FPS: 2039 FrameTime: 0.490 ms</pre>
}}

==== Intel i5-6200U @ 2.3 GHz (integrated Intel UHD 620 GPU) ====
Remark: CPU clock boosted to 2.8 GHz during benchmarking

'''glmark2 Score: 1294'''

{{collapsible script
| type = details
| title = (click show to expand)
| lang = text
| script = ----
glmark2 2021.02
----
OpenGL Information
GL_VENDOR: Intel
GL_RENDERER: Mesa Intel(R) HD Graphics 520 (SKL GT2)
GL_VERSION: 4.6 (Compatibility Profile) Mesa 21.0.3
----
[build] use-vbo=false: FPS: 1500 FrameTime: 0.667 ms
[build] use-vbo=true: FPS: 1959 FrameTime: 0.510 ms
[texture] texture-filter=nearest: FPS: 1722 FrameTime: 0.581 ms
[texture] texture-filter=linear: FPS: 1736 FrameTime: 0.576 ms
[texture] texture-filter=mipmap: FPS: 1673 FrameTime: 0.598 ms
[shading] shading=gouraud: FPS: 1584 FrameTime: 0.631 ms
[shading] shading=blinn-phong-inf: FPS: 1554 FrameTime: 0.644 ms
[shading] shading=phong: FPS: 1559 FrameTime: 0.641 ms
[shading] shading=cel: FPS: 1571 FrameTime: 0.637 ms
[bump] bump-render=high-poly: FPS: 1123 FrameTime: 0.890 ms
[bump] bump-render=normals: FPS: 1945 FrameTime: 0.514 ms
[bump] bump-render=height: FPS: 1881 FrameTime: 0.532 ms
[effect2d] kernel=0,1,0;1,-4,1;0,1,0;: FPS: 1359 FrameTime: 0.736 ms
[effect2d] kernel=1,1,1,1,1;1,1,1,1,1;1,1,1,1,1;: FPS: 851 FrameTime: 1.175 ms
[pulsar] light=false:quads=5:texture=false: FPS: 1646 FrameTime: 0.608 ms
[desktop] blur-radius=5:effect=blur:passes=1:separable=true:windows=4: FPS: 757 FrameTime: 1.321 ms
[desktop] effect=shadow:windows=4: FPS: 1094 FrameTime: 0.914 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 585 FrameTime: 1.709 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=subdata: FPS: 529 FrameTime: 1.890 ms
[buffer] columns=200:interleave=true:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 669 FrameTime: 1.495 ms
[ideas] speed=duration: FPS: 1489 FrameTime: 0.672 ms
[jellyfish] <default>: FPS: 1236 FrameTime: 0.809 ms
[terrain] <default>: FPS: 188 FrameTime: 5.319 ms
[shadow] <default>: FPS: 1014 FrameTime: 0.986 ms
[refract] <default>: FPS: 356 FrameTime: 2.809 ms
[conditionals] fragment-steps=0:vertex-steps=0: FPS: 1360 FrameTime: 0.735 ms
[conditionals] fragment-steps=5:vertex-steps=0: FPS: 1407 FrameTime: 0.711 ms
[conditionals] fragment-steps=0:vertex-steps=5: FPS: 1393 FrameTime: 0.718 ms
[function] fragment-complexity=low:fragment-steps=5: FPS: 1412 FrameTime: 0.708 ms
[function] fragment-complexity=medium:fragment-steps=5: FPS: 1416 FrameTime: 0.706 ms
[loop] fragment-loop=false:fragment-steps=5:vertex-steps=5: FPS: 1369 FrameTime: 0.730 ms
[loop] fragment-steps=5:fragment-uniform=false:vertex-steps=5: FPS: 1388 FrameTime: 0.720 ms
[loop] fragment-steps=5:fragment-uniform=true:vertex-steps=5: FPS: 1383 FrameTime: 0.723 ms
}}

=== Discrete graphics card ===
Note: this section also contains hybrid configurations (e.g. laptops with dual GPU technology)

==== AMD FirePro M5950 + Intel i5-2520M ====
Remark: dual GPU technology laptop, no test details available.

'''glmark2 Score: 5600'''

==== NVIDIA RTX2060 6GB + AMD Ryzen 7 3700X 8-Core 4GHz ====
Note: one tests resulted in errors and finally a core dump.
Another test on the same hardware, with different drivers, completed.
Both test details are included.

'''glmark2 Score: 9537'''

{{collapsible script
| type = details
| title = (click show to expand)
| lang = text
| script =----
glmark2 2021.02
----
OpenGL Information
GL_VENDOR: NVIDIA Corporation
GL_RENDERER: NVIDIA GeForce RTX 2060/PCIe/SSE2
GL_VERSION: 4.6.0 NVIDIA 495.46
----
<pre>
[build] use-vbo=false: FPS: 13809 FrameTime: 0.072 ms
[build] use-vbo=true: FPS: 28367 FrameTime: 0.035 ms
[texture] texture-filter=nearest: FPS: 27958 FrameTime: 0.036 ms
[texture] texture-filter=linear: FPS: 28120 FrameTime: 0.036 ms
[texture] texture-filter=mipmap: FPS: 28036 FrameTime: 0.036 ms
[shading] shading=gouraud: FPS: 26428 FrameTime: 0.038 ms
[shading] shading=blinn-phong-inf: FPS: 26320 FrameTime: 0.038 ms
[shading] shading=phong: FPS: 25800 FrameTime: 0.039 ms
[shading] shading=cel: FPS: 25498 FrameTime: 0.039 ms
[bump] bump-render=high-poly: FPS: 20696 FrameTime: 0.048 ms
[bump] bump-render=normals: FPS: 29599 FrameTime: 0.034 ms
Error: Failed to add fragment shader from file None:
Error: 0(15) : error C0000: syntax error, unexpected identifier, expecting "::" at token "highp"
Error: 0(36) : warning C1503: undefined variable "TextureCoord"
Error: 0(37) : warning C1503: undefined variable "TextureCoord"
Error: 0(38) : warning C1503: undefined variable "TextureCoord"
Error:
[bump] bump-render=height: Set up failed
[effect2d] kernel=0,1,0;1,-4,1;0,1,0;: FPS: 22140 FrameTime: 0.045 ms
[effect2d] kernel=1,1,1,1,1;1,1,1,1,1;1,1,1,1,1;: FPS: 15018 FrameTime: 0.067 ms
[pulsar] light=false:quads=5:texture=false: FPS: 27482 FrameTime: 0.036 ms
[desktop] blur-radius=5:effect=blur:passes=1:separable=true:windows=4: FPS: 8226 FrameTime: 0.122 ms
[desktop] effect=shadow:windows=4: FPS: 10260 FrameTime: 0.097 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 1490 FrameTime: 0.671 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=subdata: FPS: 1613 FrameTime: 0.620 ms
[buffer] columns=200:interleave=true:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 2147 FrameTime: 0.466 ms
[ideas] speed=duration: FPS: 14164 FrameTime: 0.071 ms
[jellyfish] <default>: FPS: 20591 FrameTime: 0.049 ms
Error: Failed to add fragment shader from file None:
Error: 0(26) : warning C7022: unrecognized profile specifier "highp"
Error: 0(26) : error C0502: syntax error at token "highp"
Error:
Error: Failed to add fragment shader from file None:
Error: 0(75) : warning C7022: unrecognized profile specifier "highp"
Error: 0(75) : error C0502: syntax error at token "highp"
Error:
[terrain] <default>:Segmentation fault (core dumped)</pre>
----
}}

{{collapsible script
| type = details
| title = (click show to expand)
| lang = text
| script =----
glmark2 2021.02
----
OpenGL Information
GL_VENDOR: NVIDIA Corporation
GL_RENDERER: NVIDIA GeForce RTX 2060/PCIe/SSE2
GL_VERSION: 4.6.0 NVIDIA 515.65.01
----
<pre>
[build] use-vbo=false: FPS: 8231 FrameTime: 0.121 ms
[build] use-vbo=true: FPS: 11817 FrameTime: 0.085 ms
[texture] texture-filter=nearest: FPS: 11830 FrameTime: 0.085 ms
[texture] texture-filter=linear: FPS: 11822 FrameTime: 0.085 ms
[texture] texture-filter=mipmap: FPS: 11813 FrameTime: 0.085 ms
[shading] shading=gouraud: FPS: 11501 FrameTime: 0.087 ms
[shading] shading=blinn-phong-inf: FPS: 11429 FrameTime: 0.087 ms
[shading] shading=phong: FPS: 11334 FrameTime: 0.088 ms
[shading] shading=cel: FPS: 11262 FrameTime: 0.089 ms
[bump] bump-render=high-poly: FPS: 10097 FrameTime: 0.099 ms
[bump] bump-render=normals: FPS: 12168 FrameTime: 0.082 ms
[bump] bump-render=height: FPS: 12004 FrameTime: 0.083 ms
[effect2d] kernel=0,1,0;1,-4,1;0,1,0;: FPS: 10522 FrameTime: 0.095 ms
[effect2d] kernel=1,1,1,1,1;1,1,1,1,1;1,1,1,1,1;: FPS: 8468 FrameTime: 0.118 ms
[pulsar] light=false:quads=5:texture=false: FPS: 11776 FrameTime: 0.085 ms
[desktop] blur-radius=5:effect=blur:passes=1:separable=true:windows=4: FPS: 5667 FrameTime: 0.176 ms
[desktop] effect=shadow:windows=4: FPS: 8895 FrameTime: 0.112 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 1796 FrameTime: 0.557 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=subdata: FPS: 2017 FrameTime: 0.496 ms
[buffer] columns=200:interleave=true:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 2176 FrameTime: 0.460 ms
[ideas] speed=duration: FPS: 10641 FrameTime: 0.094 ms
[jellyfish] <default>: FPS: 10085 FrameTime: 0.099 ms
[terrain] <default>: FPS: 1323 FrameTime: 0.756 ms
[shadow] <default>: FPS: 9418 FrameTime: 0.106 ms
[refract] <default>: FPS: 4595 FrameTime: 0.218 ms
[conditionals] fragment-steps=0:vertex-steps=0: FPS: 11552 FrameTime: 0.087 ms
[conditionals] fragment-steps=5:vertex-steps=0: FPS: 11498 FrameTime: 0.087 ms
[conditionals] fragment-steps=0:vertex-steps=5: FPS: 11555 FrameTime: 0.087 ms
[function] fragment-complexity=low:fragment-steps=5: FPS: 11586 FrameTime: 0.086 ms
[function] fragment-complexity=medium:fragment-steps=5: FPS: 11454 FrameTime: 0.087 ms
[loop] fragment-loop=false:fragment-steps=5:vertex-steps=5: FPS: 11521 FrameTime: 0.087 ms
[loop] fragment-steps=5:fragment-uniform=false:vertex-steps=5: FPS: 11495 FrameTime: 0.087 ms
[loop] fragment-steps=5:fragment-uniform=true:vertex-steps=5: FPS: 11403 FrameTime: 0.088 ms</pre>
}}

==== AMD Tahiti XT [Radeon HD 7970 / R9 280X] + Intel Core i5-11600K @ 3.90GHz ====

'''glmark2 Score: 13781'''

{{collapsible script
| type = details
| title = (click show to expand)
| lang = text
| script = ----
glmark2 2021.02
----
OpenGL Information
GL_VENDOR: AMD
GL_RENDERER: AMD TAHITI (DRM 2.50.0, 5.11.0-44-generic, LLVM 12.0.0)
GL_VERSION: 4.5 (Compatibility Profile) Mesa 21.0.3
----
[build] use-vbo=false: FPS: 12290 FrameTime: 0.081 ms
[build] use-vbo=true: FPS: 19086 FrameTime: 0.052 ms
[texture] texture-filter=nearest: FPS: 18131 FrameTime: 0.055 ms
[texture] texture-filter=linear: FPS: 18165 FrameTime: 0.055 ms
[texture] texture-filter=mipmap: FPS: 18563 FrameTime: 0.054 ms
[shading] shading=gouraud: FPS: 16185 FrameTime: 0.062 ms
[shading] shading=blinn-phong-inf: FPS: 16135 FrameTime: 0.062 ms
[shading] shading=phong: FPS: 16042 FrameTime: 0.062 ms
[shading] shading=cel: FPS: 16036 FrameTime: 0.062 ms
[bump] bump-render=high-poly: FPS: 9338 FrameTime: 0.107 ms
[bump] bump-render=normals: FPS: 19774 FrameTime: 0.051 ms
[bump] bump-render=height: FPS: 19534 FrameTime: 0.051 ms
[effect2d] kernel=0,1,0;1,-4,1;0,1,0;: FPS: 15477 FrameTime: 0.065 ms
[effect2d] kernel=1,1,1,1,1;1,1,1,1,1;1,1,1,1,1;: FPS: 10139 FrameTime: 0.099 ms
[pulsar] light=false:quads=5:texture=false: FPS: 16858 FrameTime: 0.059 ms
[desktop] blur-radius=5:effect=blur:passes=1:separable=true:windows=4: FPS: 5961 FrameTime: 0.168 ms
[desktop] effect=shadow:windows=4: FPS: 9994 FrameTime: 0.100 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 2577 FrameTime: 0.388 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=subdata: FPS: 3585 FrameTime: 0.279 ms
[buffer] columns=200:interleave=true:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 3158 FrameTime: 0.317 ms
[ideas] speed=duration: FPS: 11924 FrameTime: 0.084 ms
[jellyfish] <default>: FPS: 12073 FrameTime: 0.083 ms
[terrain] <default>: FPS: 1350 FrameTime: 0.741 ms
[shadow] <default>: FPS: 9986 FrameTime: 0.100 ms
[refract] <default>: FPS: 2500 FrameTime: 0.400 ms
[conditionals] fragment-steps=0:vertex-steps=0: FPS: 18815 FrameTime: 0.053 ms
[conditionals] fragment-steps=5:vertex-steps=0: FPS: 18705 FrameTime: 0.053 ms
[conditionals] fragment-steps=0:vertex-steps=5: FPS: 18787 FrameTime: 0.053 ms
[function] fragment-complexity=low:fragment-steps=5: FPS: 18759 FrameTime: 0.053 ms
[function] fragment-complexity=medium:fragment-steps=5: FPS: 18691 FrameTime: 0.054 ms
[loop] fragment-loop=false:fragment-steps=5:vertex-steps=5: FPS: 18755 FrameTime: 0.053 ms
[loop] fragment-steps=5:fragment-uniform=false:vertex-steps=5: FPS: 18759 FrameTime: 0.053 ms
[loop] fragment-steps=5:fragment-uniform=true:vertex-steps=5: FPS: 18654 FrameTime: 0.054 ms
}}

==== NVIDIA GTX-1060 6GB + AMD R7 3700X @ 4.2 GHz, 8 cores, HT off ====

'''glmark2 Score: 20641'''

{{collapsible script
| type = details
| title = (click show to expand)
| lang = text
| script = ----
glmark2 2014.03+git20150611.fa71af2d
----
OpenGL Information
GL_VENDOR: NVIDIA Corporation
GL_RENDERER: GeForce GTX 1060 6GB/PCIe/SSE2
GL_VERSION: 4.6.0 NVIDIA 460.91.03
----
[build] use-vbo=false: FPS: 15192 FrameTime: 0.066 ms
[build] use-vbo=true: FPS: 30325 FrameTime: 0.033 ms
[texture] texture-filter=nearest: FPS: 27634 FrameTime: 0.036 ms
[texture] texture-filter=linear: FPS: 27511 FrameTime: 0.036 ms
[texture] texture-filter=mipmap: FPS: 28397 FrameTime: 0.035 ms
[shading] shading=gouraud: FPS: 26079 FrameTime: 0.038 ms
[shading] shading=blinn-phong-inf: FPS: 25796 FrameTime: 0.039 ms
[shading] shading=phong: FPS: 25060 FrameTime: 0.040 ms
[shading] shading=cel: FPS: 25321 FrameTime: 0.039 ms
[bump] bump-render=high-poly: FPS: 17451 FrameTime: 0.057 ms
[bump] bump-render=normals: FPS: 31963 FrameTime: 0.031 ms
[bump] bump-render=height: FPS: 31608 FrameTime: 0.032 ms
[effect2d] kernel=0,1,0;1,-4,1;0,1,0;: FPS: 20418 FrameTime: 0.049 ms
[effect2d] kernel=1,1,1,1,1;1,1,1,1,1;1,1,1,1,1;: FPS: 12585 FrameTime: 0.079 ms
[pulsar] light=false:quads=5:texture=false: FPS: 28174 FrameTime: 0.035 ms
[desktop] blur-radius=5:effect=blur:passes=1:separable=true:windows=4: FPS: 7331 FrameTime: 0.136 ms
[desktop] effect=shadow:windows=4: FPS: 14034 FrameTime: 0.071 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 2363 FrameTime: 0.423 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=subdata: FPS: 2783 FrameTime: 0.359 ms
[buffer] columns=200:interleave=true:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 2330 FrameTime: 0.429 ms
[ideas] speed=duration: FPS: 19421 FrameTime: 0.051 ms
[jellyfish] <default>: FPS: 17291 FrameTime: 0.058 ms
[terrain] <default>: FPS: 1349 FrameTime: 0.741 ms
[shadow] <default>: FPS: 15688 FrameTime: 0.064 ms
[refract] <default>: FPS: 4783 FrameTime: 0.209 ms
[conditionals] fragment-steps=0:vertex-steps=0: FPS: 28599 FrameTime: 0.035 ms
[conditionals] fragment-steps=5:vertex-steps=0: FPS: 27499 FrameTime: 0.036 ms
[conditionals] fragment-steps=0:vertex-steps=5: FPS: 28191 FrameTime: 0.035 ms
[function] fragment-complexity=low:fragment-steps=5: FPS: 27695 FrameTime: 0.036 ms
[function] fragment-complexity=medium:fragment-steps=5: FPS: 26605 FrameTime: 0.038 ms
[loop] fragment-loop=false:fragment-steps=5:vertex-steps=5: FPS: 27340 FrameTime: 0.037 ms
[loop] fragment-steps=5:fragment-uniform=false:vertex-steps=5: FPS: 27361 FrameTime: 0.037 ms
[loop] fragment-steps=5:fragment-uniform=true:vertex-steps=5: FPS: 26984 FrameTime: 0.037 ms
}}

==== NVIDIA Quadro K1000M 1GB + Intel Core i7-3610Q @ 2.3 GHz ====
Remark: during glmark2 testing CPU clock boosted to 3.3 GHz

''' glmark2 Score: 2754 '''

{{collapsible script
| type = details
| title = (click show to expand)
| lang = text
| script = ----
glmark2 2014.03+git20150611.fa71af2d
----
OpenGL Information
GL_VENDOR: NVIDIA Corporation
GL_RENDERER: Quadro K1000M/PCIe/SSE2
GL_VERSION: 4.6.0 NVIDIA 390.138
----
[build] use-vbo=false: FPS: 4154 FrameTime: 0.241 ms
[build] use-vbo=true: FPS: 4205 FrameTime: 0.238 ms
[texture] texture-filter=nearest: FPS: 3791 FrameTime: 0.264 ms
[texture] texture-filter=linear: FPS: 3718 FrameTime: 0.269 ms
[texture] texture-filter=mipmap: FPS: 3761 FrameTime: 0.266 ms
[shading] shading=gouraud: FPS: 3187 FrameTime: 0.314 ms
[shading] shading=blinn-phong-inf: FPS: 3200 FrameTime: 0.312 ms
[shading] shading=phong: FPS: 3078 FrameTime: 0.325 ms
[shading] shading=cel: FPS: 3065 FrameTime: 0.326 ms
[bump] bump-render=high-poly: FPS: 1674 FrameTime: 0.597 ms
[bump] bump-render=normals: FPS: 4329 FrameTime: 0.231 ms
[bump] bump-render=height: FPS: 4174 FrameTime: 0.240 ms
[effect2d] kernel=0,1,0;1,-4,1;0,1,0;: FPS: 2356 FrameTime: 0.424 ms
[effect2d] kernel=1,1,1,1,1;1,1,1,1,1;1,1,1,1,1;: FPS: 1249 FrameTime: 0.801 ms
[pulsar] light=false:quads=5:texture=false: FPS: 3550 FrameTime: 0.282 ms
[desktop] blur-radius=5:effect=blur:passes=1:separable=true:windows=4: FPS: 888 FrameTime: 1.126 ms
[desktop] effect=shadow:windows=4: FPS: 1453 FrameTime: 0.688 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 952 FrameTime: 1.050 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=subdata: FPS: 1277 FrameTime: 0.783 ms
[buffer] columns=200:interleave=true:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 977 FrameTime: 1.024 ms
[ideas] speed=duration: FPS: 2926 FrameTime: 0.342 ms
[jellyfish] <default>: FPS: 1551 FrameTime: 0.645 ms
[terrain] <default>: FPS: 173 FrameTime: 5.780 ms
[shadow] <default>: FPS: 2420 FrameTime: 0.413 ms
[refract] <default>: FPS: 431 FrameTime: 2.320 ms
[conditionals] fragment-steps=0:vertex-steps=0: FPS: 3776 FrameTime: 0.265 ms
[conditionals] fragment-steps=5:vertex-steps=0: FPS: 3061 FrameTime: 0.327 ms
[conditionals] fragment-steps=0:vertex-steps=5: FPS: 3776 FrameTime: 0.265 ms
[function] fragment-complexity=low:fragment-steps=5: FPS: 3775 FrameTime: 0.265 ms
[function] fragment-complexity=medium:fragment-steps=5: FPS: 3058 FrameTime: 0.327 ms
[loop] fragment-loop=false:fragment-steps=5:vertex-steps=5: FPS: 3776 FrameTime: 0.265 ms
[loop] fragment-steps=5:fragment-uniform=false:vertex-steps=5: FPS: 3776 FrameTime: 0.265 ms
[loop] fragment-steps=5:fragment-uniform=true:vertex-steps=5: FPS: 3375 FrameTime: 0.296 ms
}}

==== NVIDIA GTX 750 + Intel Core i5-2550K @ 3.4 GHz ====
Remark: no test details available.

'''glmark2 Score: 9000'''

==== NVIDIA GTX 1060 + Intel Core i5-2550K @ 3.4 GHz ====
Remark: no test details available.

'''glmark2 Score: 19000'''

OpenGL performance

2022-08-30T10:22:37Z

MariuszXC: /* NVIDIA RTX2060 6GB + AMD Ryzen 7 3700X 8-Core 4GHz */

== OpenGL performance ==
{{See also|Profiling performance}}

OpenGL performance can be tested using glmark2 program. It is available in most Linux distributions. In Debian derived distributions (like Ubuntu) it can be installed by issuing ''sudo apt install glmark2'' from command line.

The data presented below was taken by running ''glmark2'' without any additional options, i.e. with default settings, on an otherwise idle system.

By comparing your results with measurements taken on other similar systems you can verify if your hardware and software combination is performing as expected.

=== Integrated graphics ===
==== Intel i5-4310M @ 2.70 GHz (integrated Intel HD 4600 GPU) ====

'''glmark2 Score: 1668'''

{{collapsible script
| type = details
| title = (click show to expand)
| lang = text
| script = ----
glmark2 2014.03+git20150611.fa71af2d
----
OpenGL Information
GL_VENDOR: Intel Open Source Technology Center
GL_RENDERER: Mesa DRI Intel(R) Haswell Mobile
GL_VERSION: 3.0 Mesa 18.0.5
----
<pre>
[build] use-vbo=false: FPS: 2256 FrameTime: 0.443 ms
[build] use-vbo=true: FPS: 2500 FrameTime: 0.400 ms
[texture] texture-filter=nearest: FPS: 2183 FrameTime: 0.458 ms
[texture] texture-filter=linear: FPS: 2180 FrameTime: 0.459 ms
[texture] texture-filter=mipmap: FPS: 2250 FrameTime: 0.444 ms
[shading] shading=gouraud: FPS: 2042 FrameTime: 0.490 ms
[shading] shading=blinn-phong-inf: FPS: 2049 FrameTime: 0.488 ms
[shading] shading=phong: FPS: 1938 FrameTime: 0.516 ms
[shading] shading=cel: FPS: 2037 FrameTime: 0.491 ms
[bump] bump-render=high-poly: FPS: 1701 FrameTime: 0.588 ms
[bump] bump-render=normals: FPS: 2419 FrameTime: 0.413 ms
[bump] bump-render=height: FPS: 2382 FrameTime: 0.420 ms
[effect2d] kernel=0,1,0;1,-4,1;0,1,0;: FPS: 1758 FrameTime: 0.569 ms
[effect2d] kernel=1,1,1,1,1;1,1,1,1,1;1,1,1,1,1;: FPS: 886 FrameTime: 1.129 ms
[pulsar] light=false:quads=5:texture=false: FPS: 2008 FrameTime: 0.498 ms
[desktop] blur-radius=5:effect=blur:passes=1:separable=true:windows=4: FPS: 749 FrameTime: 1.335 ms
[desktop] effect=shadow:windows=4: FPS: 1094 FrameTime: 0.914 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 770 FrameTime: 1.299 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=subdata: FPS: 655 FrameTime: 1.527 ms
[buffer] columns=200:interleave=true:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 857 FrameTime: 1.167 ms
[ideas] speed=duration: FPS: 1776 FrameTime: 0.563 ms
[jellyfish] <default>: FPS: 1275 FrameTime: 0.784 ms
[terrain] <default>: FPS: 173 FrameTime: 5.780 ms
[shadow] <default>: FPS: 805 FrameTime: 1.242 ms
[refract] <default>: FPS: 268 FrameTime: 3.731 ms
[conditionals] fragment-steps=0:vertex-steps=0: FPS: 2038 FrameTime: 0.491 ms
[conditionals] fragment-steps=5:vertex-steps=0: FPS: 2039 FrameTime: 0.490 ms
[conditionals] fragment-steps=0:vertex-steps=5: FPS: 2028 FrameTime: 0.493 ms
[function] fragment-complexity=low:fragment-steps=5: FPS: 2037 FrameTime: 0.491 ms
[function] fragment-complexity=medium:fragment-steps=5: FPS: 2051 FrameTime: 0.488 ms
[loop] fragment-loop=false:fragment-steps=5:vertex-steps=5: FPS: 1879 FrameTime: 0.532 ms
[loop] fragment-steps=5:fragment-uniform=false:vertex-steps=5: FPS: 1922 FrameTime: 0.520 ms
[loop] fragment-steps=5:fragment-uniform=true:vertex-steps=5: FPS: 2039 FrameTime: 0.490 ms</pre>
}}

==== Intel i5-6200U @ 2.3 GHz (integrated Intel UHD 620 GPU) ====
Remark: CPU clock boosted to 2.8 GHz during benchmarking

'''glmark2 Score: 1294'''

{{collapsible script
| type = details
| title = (click show to expand)
| lang = text
| script = ----
glmark2 2021.02
----
OpenGL Information
GL_VENDOR: Intel
GL_RENDERER: Mesa Intel(R) HD Graphics 520 (SKL GT2)
GL_VERSION: 4.6 (Compatibility Profile) Mesa 21.0.3
----
[build] use-vbo=false: FPS: 1500 FrameTime: 0.667 ms
[build] use-vbo=true: FPS: 1959 FrameTime: 0.510 ms
[texture] texture-filter=nearest: FPS: 1722 FrameTime: 0.581 ms
[texture] texture-filter=linear: FPS: 1736 FrameTime: 0.576 ms
[texture] texture-filter=mipmap: FPS: 1673 FrameTime: 0.598 ms
[shading] shading=gouraud: FPS: 1584 FrameTime: 0.631 ms
[shading] shading=blinn-phong-inf: FPS: 1554 FrameTime: 0.644 ms
[shading] shading=phong: FPS: 1559 FrameTime: 0.641 ms
[shading] shading=cel: FPS: 1571 FrameTime: 0.637 ms
[bump] bump-render=high-poly: FPS: 1123 FrameTime: 0.890 ms
[bump] bump-render=normals: FPS: 1945 FrameTime: 0.514 ms
[bump] bump-render=height: FPS: 1881 FrameTime: 0.532 ms
[effect2d] kernel=0,1,0;1,-4,1;0,1,0;: FPS: 1359 FrameTime: 0.736 ms
[effect2d] kernel=1,1,1,1,1;1,1,1,1,1;1,1,1,1,1;: FPS: 851 FrameTime: 1.175 ms
[pulsar] light=false:quads=5:texture=false: FPS: 1646 FrameTime: 0.608 ms
[desktop] blur-radius=5:effect=blur:passes=1:separable=true:windows=4: FPS: 757 FrameTime: 1.321 ms
[desktop] effect=shadow:windows=4: FPS: 1094 FrameTime: 0.914 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 585 FrameTime: 1.709 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=subdata: FPS: 529 FrameTime: 1.890 ms
[buffer] columns=200:interleave=true:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 669 FrameTime: 1.495 ms
[ideas] speed=duration: FPS: 1489 FrameTime: 0.672 ms
[jellyfish] <default>: FPS: 1236 FrameTime: 0.809 ms
[terrain] <default>: FPS: 188 FrameTime: 5.319 ms
[shadow] <default>: FPS: 1014 FrameTime: 0.986 ms
[refract] <default>: FPS: 356 FrameTime: 2.809 ms
[conditionals] fragment-steps=0:vertex-steps=0: FPS: 1360 FrameTime: 0.735 ms
[conditionals] fragment-steps=5:vertex-steps=0: FPS: 1407 FrameTime: 0.711 ms
[conditionals] fragment-steps=0:vertex-steps=5: FPS: 1393 FrameTime: 0.718 ms
[function] fragment-complexity=low:fragment-steps=5: FPS: 1412 FrameTime: 0.708 ms
[function] fragment-complexity=medium:fragment-steps=5: FPS: 1416 FrameTime: 0.706 ms
[loop] fragment-loop=false:fragment-steps=5:vertex-steps=5: FPS: 1369 FrameTime: 0.730 ms
[loop] fragment-steps=5:fragment-uniform=false:vertex-steps=5: FPS: 1388 FrameTime: 0.720 ms
[loop] fragment-steps=5:fragment-uniform=true:vertex-steps=5: FPS: 1383 FrameTime: 0.723 ms
}}

=== Discrete graphics card ===
Note: this section also contains hybrid configurations (e.g. laptops with dual GPU technology)

==== AMD FirePro M5950 + Intel i5-2520M ====
Remark: dual GPU technology laptop, no test details available.

'''glmark2 Score: 5600'''

==== NVIDIA RTX2060 6GB + AMD Ryzen 7 3700X 8-Core 4GHz ====
Note: one tests resulted in errors and finally a core dump.
Another test on the same hardware, with different drivers, completed.
Both test details are included.

'''glmark2 Score: 9537'''

{{collapsible script
| type = details
| title = (click show to expand)
| lang = text
| script =----
glmark2 2021.02
----
OpenGL Information
GL_VENDOR: NVIDIA Corporation
GL_RENDERER: NVIDIA GeForce RTX 2060/PCIe/SSE2
GL_VERSION: 4.6.0 NVIDIA 495.46
----
<pre>
[build] use-vbo=false: FPS: 13809 FrameTime: 0.072 ms
[build] use-vbo=true: FPS: 28367 FrameTime: 0.035 ms
[texture] texture-filter=nearest: FPS: 27958 FrameTime: 0.036 ms
[texture] texture-filter=linear: FPS: 28120 FrameTime: 0.036 ms
[texture] texture-filter=mipmap: FPS: 28036 FrameTime: 0.036 ms
[shading] shading=gouraud: FPS: 26428 FrameTime: 0.038 ms
[shading] shading=blinn-phong-inf: FPS: 26320 FrameTime: 0.038 ms
[shading] shading=phong: FPS: 25800 FrameTime: 0.039 ms
[shading] shading=cel: FPS: 25498 FrameTime: 0.039 ms
[bump] bump-render=high-poly: FPS: 20696 FrameTime: 0.048 ms
[bump] bump-render=normals: FPS: 29599 FrameTime: 0.034 ms
Error: Failed to add fragment shader from file None:
Error: 0(15) : error C0000: syntax error, unexpected identifier, expecting "::" at token "highp"
Error: 0(36) : warning C1503: undefined variable "TextureCoord"
Error: 0(37) : warning C1503: undefined variable "TextureCoord"
Error: 0(38) : warning C1503: undefined variable "TextureCoord"
Error:
[bump] bump-render=height: Set up failed
[effect2d] kernel=0,1,0;1,-4,1;0,1,0;: FPS: 22140 FrameTime: 0.045 ms
[effect2d] kernel=1,1,1,1,1;1,1,1,1,1;1,1,1,1,1;: FPS: 15018 FrameTime: 0.067 ms
[pulsar] light=false:quads=5:texture=false: FPS: 27482 FrameTime: 0.036 ms
[desktop] blur-radius=5:effect=blur:passes=1:separable=true:windows=4: FPS: 8226 FrameTime: 0.122 ms
[desktop] effect=shadow:windows=4: FPS: 10260 FrameTime: 0.097 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 1490 FrameTime: 0.671 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=subdata: FPS: 1613 FrameTime: 0.620 ms
[buffer] columns=200:interleave=true:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 2147 FrameTime: 0.466 ms
[ideas] speed=duration: FPS: 14164 FrameTime: 0.071 ms
[jellyfish] <default>: FPS: 20591 FrameTime: 0.049 ms
Error: Failed to add fragment shader from file None:
Error: 0(26) : warning C7022: unrecognized profile specifier "highp"
Error: 0(26) : error C0502: syntax error at token "highp"
Error:
Error: Failed to add fragment shader from file None:
Error: 0(75) : warning C7022: unrecognized profile specifier "highp"
Error: 0(75) : error C0502: syntax error at token "highp"
Error:
[terrain] <default>:Segmentation fault (core dumped)</pre>
----
}}

{{collapsible script
| type = details
| title = (click show to expand)
| lang = text
| script =----
glmark2 2021.02
----
OpenGL Information
GL_VENDOR: NVIDIA Corporation
GL_RENDERER: NVIDIA GeForce RTX 2060/PCIe/SSE2
GL_VERSION: 4.6.0 NVIDIA 515.65.01
----
<pre>
[build] use-vbo=false: FPS: 8231 FrameTime: 0.121 ms
[build] use-vbo=true: FPS: 11817 FrameTime: 0.085 ms
[texture] texture-filter=nearest: FPS: 11830 FrameTime: 0.085 ms
[texture] texture-filter=linear: FPS: 11822 FrameTime: 0.085 ms
[texture] texture-filter=mipmap: FPS: 11813 FrameTime: 0.085 ms
[shading] shading=gouraud: FPS: 11501 FrameTime: 0.087 ms
[shading] shading=blinn-phong-inf: FPS: 11429 FrameTime: 0.087 ms
[shading] shading=phong: FPS: 11334 FrameTime: 0.088 ms
[shading] shading=cel: FPS: 11262 FrameTime: 0.089 ms
[bump] bump-render=high-poly: FPS: 10097 FrameTime: 0.099 ms
[bump] bump-render=normals: FPS: 12168 FrameTime: 0.082 ms
[bump] bump-render=height: FPS: 12004 FrameTime: 0.083 ms
[effect2d] kernel=0,1,0;1,-4,1;0,1,0;: FPS: 10522 FrameTime: 0.095 ms
[effect2d] kernel=1,1,1,1,1;1,1,1,1,1;1,1,1,1,1;: FPS: 8468 FrameTime: 0.118 ms
[pulsar] light=false:quads=5:texture=false: FPS: 11776 FrameTime: 0.085 ms
[desktop] blur-radius=5:effect=blur:passes=1:separable=true:windows=4: FPS: 5667 FrameTime: 0.176 ms
[desktop] effect=shadow:windows=4: FPS: 8895 FrameTime: 0.112 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 1796 FrameTime: 0.557 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=subdata: FPS: 2017 FrameTime: 0.496 ms
[buffer] columns=200:interleave=true:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 2176 FrameTime: 0.460 ms
[ideas] speed=duration: FPS: 10641 FrameTime: 0.094 ms
[jellyfish] <default>: FPS: 10085 FrameTime: 0.099 ms
[terrain] <default>: FPS: 1323 FrameTime: 0.756 ms
[shadow] <default>: FPS: 9418 FrameTime: 0.106 ms
[refract] <default>: FPS: 4595 FrameTime: 0.218 ms
[conditionals] fragment-steps=0:vertex-steps=0: FPS: 11552 FrameTime: 0.087 ms
[conditionals] fragment-steps=5:vertex-steps=0: FPS: 11498 FrameTime: 0.087 ms
[conditionals] fragment-steps=0:vertex-steps=5: FPS: 11555 FrameTime: 0.087 ms
[function] fragment-complexity=low:fragment-steps=5: FPS: 11586 FrameTime: 0.086 ms
[function] fragment-complexity=medium:fragment-steps=5: FPS: 11454 FrameTime: 0.087 ms
[loop] fragment-loop=false:fragment-steps=5:vertex-steps=5: FPS: 11521 FrameTime: 0.087 ms
[loop] fragment-steps=5:fragment-uniform=false:vertex-steps=5: FPS: 11495 FrameTime: 0.087 ms
[loop] fragment-steps=5:fragment-uniform=true:vertex-steps=5: FPS: 11403 FrameTime: 0.088 ms</pre>
----
}}

==== AMD Tahiti XT [Radeon HD 7970 / R9 280X] + Intel Core i5-11600K @ 3.90GHz ====

'''glmark2 Score: 13781'''

{{collapsible script
| type = details
| title = (click show to expand)
| lang = text
| script = ----
glmark2 2021.02
----
OpenGL Information
GL_VENDOR: AMD
GL_RENDERER: AMD TAHITI (DRM 2.50.0, 5.11.0-44-generic, LLVM 12.0.0)
GL_VERSION: 4.5 (Compatibility Profile) Mesa 21.0.3
----
[build] use-vbo=false: FPS: 12290 FrameTime: 0.081 ms
[build] use-vbo=true: FPS: 19086 FrameTime: 0.052 ms
[texture] texture-filter=nearest: FPS: 18131 FrameTime: 0.055 ms
[texture] texture-filter=linear: FPS: 18165 FrameTime: 0.055 ms
[texture] texture-filter=mipmap: FPS: 18563 FrameTime: 0.054 ms
[shading] shading=gouraud: FPS: 16185 FrameTime: 0.062 ms
[shading] shading=blinn-phong-inf: FPS: 16135 FrameTime: 0.062 ms
[shading] shading=phong: FPS: 16042 FrameTime: 0.062 ms
[shading] shading=cel: FPS: 16036 FrameTime: 0.062 ms
[bump] bump-render=high-poly: FPS: 9338 FrameTime: 0.107 ms
[bump] bump-render=normals: FPS: 19774 FrameTime: 0.051 ms
[bump] bump-render=height: FPS: 19534 FrameTime: 0.051 ms
[effect2d] kernel=0,1,0;1,-4,1;0,1,0;: FPS: 15477 FrameTime: 0.065 ms
[effect2d] kernel=1,1,1,1,1;1,1,1,1,1;1,1,1,1,1;: FPS: 10139 FrameTime: 0.099 ms
[pulsar] light=false:quads=5:texture=false: FPS: 16858 FrameTime: 0.059 ms
[desktop] blur-radius=5:effect=blur:passes=1:separable=true:windows=4: FPS: 5961 FrameTime: 0.168 ms
[desktop] effect=shadow:windows=4: FPS: 9994 FrameTime: 0.100 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 2577 FrameTime: 0.388 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=subdata: FPS: 3585 FrameTime: 0.279 ms
[buffer] columns=200:interleave=true:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 3158 FrameTime: 0.317 ms
[ideas] speed=duration: FPS: 11924 FrameTime: 0.084 ms
[jellyfish] <default>: FPS: 12073 FrameTime: 0.083 ms
[terrain] <default>: FPS: 1350 FrameTime: 0.741 ms
[shadow] <default>: FPS: 9986 FrameTime: 0.100 ms
[refract] <default>: FPS: 2500 FrameTime: 0.400 ms
[conditionals] fragment-steps=0:vertex-steps=0: FPS: 18815 FrameTime: 0.053 ms
[conditionals] fragment-steps=5:vertex-steps=0: FPS: 18705 FrameTime: 0.053 ms
[conditionals] fragment-steps=0:vertex-steps=5: FPS: 18787 FrameTime: 0.053 ms
[function] fragment-complexity=low:fragment-steps=5: FPS: 18759 FrameTime: 0.053 ms
[function] fragment-complexity=medium:fragment-steps=5: FPS: 18691 FrameTime: 0.054 ms
[loop] fragment-loop=false:fragment-steps=5:vertex-steps=5: FPS: 18755 FrameTime: 0.053 ms
[loop] fragment-steps=5:fragment-uniform=false:vertex-steps=5: FPS: 18759 FrameTime: 0.053 ms
[loop] fragment-steps=5:fragment-uniform=true:vertex-steps=5: FPS: 18654 FrameTime: 0.054 ms
}}

==== NVIDIA GTX-1060 6GB + AMD R7 3700X @ 4.2 GHz, 8 cores, HT off ====

'''glmark2 Score: 20641'''

{{collapsible script
| type = details
| title = (click show to expand)
| lang = text
| script = ----
glmark2 2014.03+git20150611.fa71af2d
----
OpenGL Information
GL_VENDOR: NVIDIA Corporation
GL_RENDERER: GeForce GTX 1060 6GB/PCIe/SSE2
GL_VERSION: 4.6.0 NVIDIA 460.91.03
----
[build] use-vbo=false: FPS: 15192 FrameTime: 0.066 ms
[build] use-vbo=true: FPS: 30325 FrameTime: 0.033 ms
[texture] texture-filter=nearest: FPS: 27634 FrameTime: 0.036 ms
[texture] texture-filter=linear: FPS: 27511 FrameTime: 0.036 ms
[texture] texture-filter=mipmap: FPS: 28397 FrameTime: 0.035 ms
[shading] shading=gouraud: FPS: 26079 FrameTime: 0.038 ms
[shading] shading=blinn-phong-inf: FPS: 25796 FrameTime: 0.039 ms
[shading] shading=phong: FPS: 25060 FrameTime: 0.040 ms
[shading] shading=cel: FPS: 25321 FrameTime: 0.039 ms
[bump] bump-render=high-poly: FPS: 17451 FrameTime: 0.057 ms
[bump] bump-render=normals: FPS: 31963 FrameTime: 0.031 ms
[bump] bump-render=height: FPS: 31608 FrameTime: 0.032 ms
[effect2d] kernel=0,1,0;1,-4,1;0,1,0;: FPS: 20418 FrameTime: 0.049 ms
[effect2d] kernel=1,1,1,1,1;1,1,1,1,1;1,1,1,1,1;: FPS: 12585 FrameTime: 0.079 ms
[pulsar] light=false:quads=5:texture=false: FPS: 28174 FrameTime: 0.035 ms
[desktop] blur-radius=5:effect=blur:passes=1:separable=true:windows=4: FPS: 7331 FrameTime: 0.136 ms
[desktop] effect=shadow:windows=4: FPS: 14034 FrameTime: 0.071 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 2363 FrameTime: 0.423 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=subdata: FPS: 2783 FrameTime: 0.359 ms
[buffer] columns=200:interleave=true:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 2330 FrameTime: 0.429 ms
[ideas] speed=duration: FPS: 19421 FrameTime: 0.051 ms
[jellyfish] <default>: FPS: 17291 FrameTime: 0.058 ms
[terrain] <default>: FPS: 1349 FrameTime: 0.741 ms
[shadow] <default>: FPS: 15688 FrameTime: 0.064 ms
[refract] <default>: FPS: 4783 FrameTime: 0.209 ms
[conditionals] fragment-steps=0:vertex-steps=0: FPS: 28599 FrameTime: 0.035 ms
[conditionals] fragment-steps=5:vertex-steps=0: FPS: 27499 FrameTime: 0.036 ms
[conditionals] fragment-steps=0:vertex-steps=5: FPS: 28191 FrameTime: 0.035 ms
[function] fragment-complexity=low:fragment-steps=5: FPS: 27695 FrameTime: 0.036 ms
[function] fragment-complexity=medium:fragment-steps=5: FPS: 26605 FrameTime: 0.038 ms
[loop] fragment-loop=false:fragment-steps=5:vertex-steps=5: FPS: 27340 FrameTime: 0.037 ms
[loop] fragment-steps=5:fragment-uniform=false:vertex-steps=5: FPS: 27361 FrameTime: 0.037 ms
[loop] fragment-steps=5:fragment-uniform=true:vertex-steps=5: FPS: 26984 FrameTime: 0.037 ms
}}

==== NVIDIA Quadro K1000M 1GB + Intel Core i7-3610Q @ 2.3 GHz ====
Remark: during glmark2 testing CPU clock boosted to 3.3 GHz

''' glmark2 Score: 2754 '''

{{collapsible script
| type = details
| title = (click show to expand)
| lang = text
| script = ----
glmark2 2014.03+git20150611.fa71af2d
----
OpenGL Information
GL_VENDOR: NVIDIA Corporation
GL_RENDERER: Quadro K1000M/PCIe/SSE2
GL_VERSION: 4.6.0 NVIDIA 390.138
----
[build] use-vbo=false: FPS: 4154 FrameTime: 0.241 ms
[build] use-vbo=true: FPS: 4205 FrameTime: 0.238 ms
[texture] texture-filter=nearest: FPS: 3791 FrameTime: 0.264 ms
[texture] texture-filter=linear: FPS: 3718 FrameTime: 0.269 ms
[texture] texture-filter=mipmap: FPS: 3761 FrameTime: 0.266 ms
[shading] shading=gouraud: FPS: 3187 FrameTime: 0.314 ms
[shading] shading=blinn-phong-inf: FPS: 3200 FrameTime: 0.312 ms
[shading] shading=phong: FPS: 3078 FrameTime: 0.325 ms
[shading] shading=cel: FPS: 3065 FrameTime: 0.326 ms
[bump] bump-render=high-poly: FPS: 1674 FrameTime: 0.597 ms
[bump] bump-render=normals: FPS: 4329 FrameTime: 0.231 ms
[bump] bump-render=height: FPS: 4174 FrameTime: 0.240 ms
[effect2d] kernel=0,1,0;1,-4,1;0,1,0;: FPS: 2356 FrameTime: 0.424 ms
[effect2d] kernel=1,1,1,1,1;1,1,1,1,1;1,1,1,1,1;: FPS: 1249 FrameTime: 0.801 ms
[pulsar] light=false:quads=5:texture=false: FPS: 3550 FrameTime: 0.282 ms
[desktop] blur-radius=5:effect=blur:passes=1:separable=true:windows=4: FPS: 888 FrameTime: 1.126 ms
[desktop] effect=shadow:windows=4: FPS: 1453 FrameTime: 0.688 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 952 FrameTime: 1.050 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=subdata: FPS: 1277 FrameTime: 0.783 ms
[buffer] columns=200:interleave=true:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 977 FrameTime: 1.024 ms
[ideas] speed=duration: FPS: 2926 FrameTime: 0.342 ms
[jellyfish] <default>: FPS: 1551 FrameTime: 0.645 ms
[terrain] <default>: FPS: 173 FrameTime: 5.780 ms
[shadow] <default>: FPS: 2420 FrameTime: 0.413 ms
[refract] <default>: FPS: 431 FrameTime: 2.320 ms
[conditionals] fragment-steps=0:vertex-steps=0: FPS: 3776 FrameTime: 0.265 ms
[conditionals] fragment-steps=5:vertex-steps=0: FPS: 3061 FrameTime: 0.327 ms
[conditionals] fragment-steps=0:vertex-steps=5: FPS: 3776 FrameTime: 0.265 ms
[function] fragment-complexity=low:fragment-steps=5: FPS: 3775 FrameTime: 0.265 ms
[function] fragment-complexity=medium:fragment-steps=5: FPS: 3058 FrameTime: 0.327 ms
[loop] fragment-loop=false:fragment-steps=5:vertex-steps=5: FPS: 3776 FrameTime: 0.265 ms
[loop] fragment-steps=5:fragment-uniform=false:vertex-steps=5: FPS: 3776 FrameTime: 0.265 ms
[loop] fragment-steps=5:fragment-uniform=true:vertex-steps=5: FPS: 3375 FrameTime: 0.296 ms
}}

==== NVIDIA GTX 750 + Intel Core i5-2550K @ 3.4 GHz ====
Remark: no test details available.

'''glmark2 Score: 9000'''

==== NVIDIA GTX 1060 + Intel Core i5-2550K @ 3.4 GHz ====
Remark: no test details available.

'''glmark2 Score: 19000'''

FGQCanvas

2022-05-27T12:08:20Z

MariuszXC: minor typo correction (protocol name is HTTP)

{{Canvas Navigation}} 
[[File:FGQCanvas Boeing 747-400 PFD and ND.png|thumb|FGQCanvas window showing the PFD, ND and EICAS of the [[Boeing 747-400]].]]

'''FGQCanvas''' is a Qt-based remote [[canvas]] application for [[FlightGear]]. This app can connect to a FlightGear instance which has the built-in HTTP server enabled and display any canvas in real-time at any resolution and/or relative positioning.

== Usage ==
See {{repo link
| site = sf
| repo = flightgear
| path = utils/fgqcanvas/README.md
| pre = $FLIGHTGEAR_SRC
}} for instructions on how to use FGQCanvas.

# Launch FlightGear with <code>--httpd=8080</code>.
# Launch FGQCanvas.
# Follow the on-screen instructions.

== Background ==
{{See also|FGCanvas}}
James has spent some of his time since FSWeekend 2016 figuring out how he might drive some ‘real’ CDU hardware from the in-aircraft CDU options, and went for a slightly ambitious approach: he's written an analogue of [[FGPanel]] for the [[canvas]].

Analogue is actually not quite correct - unlike FGpanel this connects at the view level (canvas properties), it doesn’t run the canvas ‘model’ locally, since that would be very tough ([[Nasal]] + whole [[property tree]] needed).

This distinction was unimportant for the canvas up until now, but it’s going to become important he expects.
This was prompted by his intention to buy something like this: http://www.flightdecksolutions.com/components/b737ng/b737ng-mipmain/fds-b737ng-pro-mx-cdu-color-vga/
Which means James needs the CDU screen running on its own screen/device nicely.

And he already wrote a page-based Canvas CDU over a year ago, it’s just sitting on Gijs’ hard-drive awaiting being merged.

This is currently proof-of-concept quality, but already works quite nicely:

* uses a websocket to send an entire property sub-tree (a canvas, but in principle could be anything) to another process / machine
* render the canvas at arbitrary sie/resolution
* it’s ten source files and very simple code

It looks like this:
(see the [http://fgfs.goneabitbursar.com/screenshots/remote-canvas-nd.png linked image])<ref>{{cite web
|url = https://forum.flightgear.org/viewtopic.php?p=300990#p300990
|title = <nowiki> </nowiki>
|author = <nowiki> zakalawe </nowiki>
|date = Dec 10th, 2016
|added = Dec 10th, 2016
|script_version = 0.40
}}</ref>

== Status ==
James is very happy with this approach so far, since any Canvas display can be trivially run out-of-process, remotely on an Android tablet, Raspberry Pi, iPhone or whatever. (he is hoping to make an app available on the Play store and App store, but one thing at a time). The 777 ND and lower EICAS pages work and look great at larger sizes. James also investigated using a binary protocol for doing the mirroring, current one is an optimised JSON protocol but swapping in a binary protocol is very doable in the future.<ref>{{cite web
|url = https://forum.flightgear.org/viewtopic.php?p=300990#p300990
|title = <nowiki> </nowiki>
|author = <nowiki> zakalawe </nowiki>
|date = Dec 10th, 2016
|added = Dec 10th, 2016
|script_version = 0.40
}}</ref>

This has prompted James to look at some more fundamental pieces of the Canvas, because there are some things the Canvas / Map layer do which are not very performance-friendly, especially the symbol-caching / texture-atlasing can be managed better on the rendering-client side. (Plus all the overhead that comes from doing lots of work in Nasal) The system would benefit from some knowledge about screen-space pixel size, so that each per-frame change in heading / aircraft position does not cause every symbol and route-path element to be recomputed in cartesian space and then re-transmitted over the mirror-socket. (But, even doing that, and with a software rendering, it’s still fast - computers are really quick….)<ref>{{cite web
|url = https://sourceforge.net/p/flightgear/mailman/message/35543715/
|title = <nowiki> [Flightgear-devel] Announcement: Remote canvas </nowiki>
|author = <nowiki> James Turner </nowiki>
|date = Dec 10th, 2016
|added = Dec 10th, 2016
|script_version = 0.40
}}</ref>

== References ==
{{Appendix}}

Hackathon Proposal: Multiplayer Improvements

2022-01-13T18:43:25Z

MariuszXC: /* Progress after the Hackaton (current state) */

{{Hackathon Proposal 2021
| title = Multiplayer Improvements
| sponsor = MariuszXC
| supporters = MariuszXC
| summary = Improving ground-referenced presentation of remote players' planes
| background = forum topic https://forum.flightgear.org/viewtopic.php?f=4&t=39846
| details = Due to scenery differences some aircraft are shown partially sunk or floating, even when their GND flag is true.
| skills = Nasal
}}

=== Progress during the Hackaton ===

Under the topic of Multiplayer Improvements we actually worked on two issues:
* ground reference of remote aircraft,
* tracing a cause of low resolution remote aircraft model displayed together with the cockpit model.

With the first issue we had success applying the necessary corrections, so a model does not appear floating or partially sunk.
Since the offset needed to be applied to a low-res model and to the high-res may be different, we are investigating further on how to dynamically decide which needs to be applied.

With the second issue we identified the cause of the problem, defined a solution and are working on implementing it.

=== Progress after the Hackaton (current state) ===

We tested a solution to the second problem and found it working. We are now waiting for a code review.

Update:
Code review passed with success.
As of commit ID bda359 our solution is in Flight Gear.

PropertyList XML files

2022-01-12T09:26:49Z

MariuszXC: /* Aliasing combined with inclusion */ - corrected xml closing tag

{{PropertyTree}}

Most configuration files in FlightGear are '''PropertyList XML files''' using a subset of XML to encode lists and trees of [[Property Tree Intro|properties]] as XML. PropertyList-XML files are the main mechanism to populate the FlightGear property tree (or a sub branch of it) from XML files, but also to serialize (save) property tree/branch state to an XML file. XML attributes are mainly used as meta-directives for the property tree.

{{Note|
{{FGCquote
|any --prop: argument can be just as well added to preferences.xml<br/>
For that, you only need to understand how properties are mapped to XML space and vice versa:
<syntaxhighlight lang="xml">
<sim>
<foo n="0">teddy</foo>
<foo n="1">tiger</foo>
</sim>
</syntaxhighlight>these can be expressed using <nowiki>--prop:/sim/foo[0]=teddy and --prop:/sim/foo[1]=tiger</nowiki>
You should however not edit $FG_ROOT/preferences.xml directly - which should be considered readonly, instead, use $FG_HOME, which will be treated as an overlay (on top of $FG_ROOT/preferences.xml).
|{{cite web |url=http://forum.flightgear.org/viewtopic.php?p=234298#p234298
|title=<nowiki>Re: Command line arguments with 3.4 launcher?</nowiki>
|author=<nowiki>Hooray</nowiki>
|date=<nowiki>Fri Mar 06</nowiki>
}}
}}
}}

For additional background information, you'll also want to refer to [[$FG_ROOT]]/Docs/README.introduction.

== Advantages ==
One advantage of the XML representation is its conceptual simplicity. Every element except for the root PropertyList container represents exactly one property, and every attribute represents metadata for the property associated with its element.

To work with PropertyList-XML files, you can use various means, such as:
* fgcommands
* Nasal (props.nas, io.nas)
* C++ APIs (see links at the end of the navigation sidebar)
* Text editor: manually edit XML files

Right now, we use attributes for meta-information (data type, read/write flags, aliasing, and tracing). As long as we use attributes for meta-information and elements for data, we'll have a clean upgrade path; otherwise, we could end up with lots of reserved names (like you could not have a property named "alias", for example, because it would conflict with the attribute), and versioning problems (there's a new attribute named "foo", so any existing "foo" properties have to be renamed).

The current practice is a little verbose compared with a custom-designed, single-purpose XML format, but it generalizes nicely. Another alternative would be to use XML Namespaces, but (while I support them) those have their detractors even in the hard-core XML community, and I'm worried that they'll confuse people a bit in FlightGear.

A custom-designed XML format for panels, sound, animations, FDMs, etc. could be *much* less verbose, but then we'd be managing n different XML-based formats and parsing libraries.

== Read and write access ==
{{IO Restrictions}}

== The PropertyList format ==
The root element of each file is always named <PropertyList>. Tags are almost always found in pairs, with the closing tag having a slash prefixing the tag name, i.e </PropertyList>, just like in any other XML dialect. The exception is the tag representing an aliased property. In this case a slash is prepended to the closing angle bracket:

<syntaxhighlight lang="xml">
<prop alias="/sim/foo"/>
</syntaxhighlight>

=== Minimal example ===
A minimal example of a complete property list encoded XML file, looks like this:

<syntaxhighlight lang="xml">
<?xml version="1.0" encoding="UTF-8"?>

<PropertyList>
</PropertyList>
</syntaxhighlight>

=== Property node tags and attributes ===
Each node in a tree is specified using a single tag that can take attributes describing various things about it:

<syntaxhighlight lang="xml">
<?xml version="1.0" encoding="UTF-8"?>
<PropertyList>
<welcome type="string">Welcome to FlightGear! This is a string as a property</welcome>
</PropertyList>
</syntaxhighlight>

=== Property type attributes ===
Property typing is optional, all properties are by default string/unspecified and are transparently converted by the property tree, but it never hurts, especially when including spaces around numbers:

<syntaxhighlight lang="xml">
<?xml version="1.0" encoding="UTF-8"?>
<PropertyList>
<foo type="string">Hello</foo>
<pi type="float"> 3.14 </pi>
<boo type="bool">true</boo>
</PropertyList>
</syntaxhighlight>

=== Indexed nodes ===
Indexing happens implicitly for identically named properties:

<syntaxhighlight lang="xml">
<?xml version="1.0" encoding="UTF-8"?>
<PropertyList>
<foo>Hello</foo>
<foo>Hello</foo>
<foo>Hello</foo>
</PropertyList>
</syntaxhighlight>

so that the three foo tags become foo[0], foo[1], foo[2] in the property tree, but you can also use explicit indexing by setting the '''n''' attribute of each tag:

<syntaxhighlight lang="xml">
<?xml version="1.0" encoding="UTF-8"?>
<PropertyList>
<foo n="0">Hello</foo>
<foo n="1">Hello</foo>
<foo n="2">Hello</foo>
</PropertyList>
</syntaxhighlight>

Though the above two examples are equivalent, we tend often to include "n" anyway, just to help people keep track of where they are. That's most important when there are a lot of subproperties, not in a simple list like the above.

=== Archived properties ===
To make property settings persistent in between FlightGear sessions, use the userarchive attribute:

<syntaxhighlight lang="xml">
<?xml version="1.0" encoding="UTF-8"?>
<PropertyList>
<foo userarchive="y">Hello</foo>
</PropertyList>
</syntaxhighlight>

=== Including external PropertyList files ===
We can also create new PropertyList files by subtyping existing ones using the include attribute. For example, if someone made a DC-3 model for JSBSim, we could subclass from the YASim config file like this:

<syntaxhighlight lang="xml">
<?xml version="1.0" encoding="UTF-8"?>
<PropertyList include="dc3-yasim-set.xml">
<sim>
<description>DC-3 (JSBSim).</description>
<flight-model archive="y">jsb</flight-model>
</sim>
</PropertyList>
</syntaxhighlight>

Emmanuel Baranger's models tend to use this technique lot and often have several XML files: the first (the -set.xml) contains very basic information, often just author and version number, and includes the next; the second is for FDM-specific properties (the -yasim-cnf or -jsbsim-cnf); and the last has FDM-independent things like flap settings (the -base.xml). This structuring allows for maximum reusability between FDMs and makes it easier for someone to come along and add another FDM to a model.

{{Caution|The 'new' vec*d types are not fully/propertly integrated with the underlying PropertyTree APIs yet, which means that some things may not work as expected, which is particularly important when dealing with files using those types (e.g. effects - see below for details).
{{FGCquote
|Instead of:
<syntaxhighlight lang="xml">
<effect include="Aircraft/f16/Models/Effects/glass/glass.xml"/>
</syntaxhighlight>
It is best to use
<syntaxhighlight lang="xml">
<effect>
<inherits-from>Aircraft/f16/Models/Effects/glass/glass</inherits-from><br/>
</effect>
</syntaxhighlight>
|{{cite web |url=http://sourceforge.net/p/flightgear/mailman/message/33606423/
|title=<nowiki>Re: [Flightgear-devel] xml: Unrecognized data type 'vec3d (Was:
Cockpit glass effect)</nowiki>
|author=<nowiki>Erik Hofman</nowiki>
|date=<nowiki>2015-03-17</nowiki>
}}
}}
}}

=== Aliased properties ===
Properties can alias other properties, in a similar way to symbolic links in Unix. When one of them changes the other one changes as well.

For example, this

<syntaxhighlight lang="xml">
<?xml version="1.0" encoding="UTF-8"?>
<PropertyList>
<foo>46</foo>
<bar alias="/foo"/>
</PropertyList>
</syntaxhighlight>

will be functionally identical to

<syntaxhighlight lang="xml">
<?xml version="1.0" encoding="UTF-8"?>
<PropertyList>
<foo>46</foo>
<bar>46</bar>
</PropertyList>
</syntaxhighlight>

except that bar and foo will always be identical.

A PropertyList file can begin with a property subtree that are aliased later in the file.

<syntaxhighlight lang="xml">
<?xml version="1.0" encoding="UTF-8"?>
<PropertyList>
<params>
<comm-freq-prop>/radios/comm1/frequencies/selected</comm-freq-prop>
<nav-freq-prop>/radios/nav1/frequencies/selected</nav-freq-prop>
</params>
<chunk>
<type>number-value</type>
<property alias="/params/nav-freq-prop"/>
</chunk>
</PropertyList>
</syntaxhighlight>

=== Aliasing combined with inclusion ===
The combination of aliasing and inclusion allows for parameterization, which can be of great help both for debugging and mainenance. The above example could for example instead be split up into

<syntaxhighlight lang="xml">
<?xml version="1.0" encoding="UTF-8"?>
<PropertyList>
<params>
<comm-freq-prop>/radios/comm1/frequencies/selected</comm-freq-prop>
<nav-freq-prop>/radios/nav1/frequencies/selected</nav-freq-prop>
</params>
</PropertyList>
</syntaxhighlight>

and

<syntaxhighlight lang="xml">
<?xml version="1.0" encoding="UTF-8"?>
<PropertyList>
<params include="MyParams.xml"/>
<chunk>
<type>number-value</type>
<property alias="/params/nav-freq-prop"/>
</chunk>
</PropertyList>
</syntaxhighlight>

The parameters can be overridden at inclusion

<syntaxhighlight lang="xml">
<?xml version="1.0" encoding="UTF-8"?>
<PropertyList>
<instrument include="../Instruments/navcomm.xml">
<params>
<comm-freq-prop>/radios/comm1/frequencies/selected</comm-freq-prop>
<nav-freq-prop>/radios/nav1/frequencies/selected</nav-freq-prop>
</params>
</instrument>
</PropertyList>
</syntaxhighlight>

<syntaxhighlight lang="xml">
<?xml version="1.0" encoding="UTF-8"?>
<PropertyList>
<instrument include="../Instruments/navcomm.xml">
<params>
<comm-freq-prop>/radios/comm2/frequencies/selected</comm-freq-prop>
<nav-freq-prop>/radios/nav2/frequencies/selected</nav-freq-prop>
</params>
</instrument>
</PropertyList>
</syntaxhighlight>

== CDATA ==
Whenever you need to embed text that isn't valid XML, because it may contain XML tokens, you need to wrap the whole section in a CDATA section, this is typically done with [[Nasal]] code, so that it doesn't need to escape XML entities:

<syntaxhighlight lang="xml">
<?xml version="1.0" encoding="UTF-8"?>
<PropertyList>
<nasal>
<![CDATA[
# begin of code
print("\n");
# end of code
]]>
</nasal>
</PropertyList>

</syntaxhighlight>

Note how the CDATA section now contains tokens/characters that would otherwise make the XML markup invalid.

== PropertyList-based configuration files ==
Not everything that is read from an XML file resides in the main property tree; some subsystems also use XML files for initial configuration information and are read into a temporary tree and subsequently discarded. The main property tree is meant to represent the shared state of the program, but when a subsystem happens to use an XML file to set up its internal state that information is ofteb of no use to the rest of the program and thus does not need to continually be in the main tree. Temporary trees are usually deleted as soon as the subsystem is set up (i.e. they exist for perhaps 0.1 sec). We could just as easily use another format for internal initialization, but since the XML support is already available, it was the easiest route.

The config files serve many different purposes; using the XML-based property-list format for all of them helps a lot, since it allows some common structure and reusable code among all the formats. Imagine if we had one file format for preferences, a different one for panels (say, with fixed-length fields), a different one for saving a flight (perhaps a binary format), another one for sound configuration (perhaps an INI file), a different one for top-level aircraft configuration (perhaps CSV), yet another one for configuring 3D models (perhaps embedded data strings in the 3D files themselves), etc. etc.

We have config files for totally different purposes, and the fact that they all use XML is simply a convenience for programmers and customizers.
Here are some of the conventions that we've come up with so far, partly ad-hoc (all paths relative to $FG_ROOT):

* preferences.xml - the top-level default preferences
* joysticks.xml - default joystick bindings, included by preferences.xml
* keyboard.xml - default keyboard bindings, included by preferences.xml
* Aircraft/*-set.xml - aircraft-specific settings, overriding the defaults in preferences.xml (and joystick/keyboard.xml)

Basically, these are the main files in the base package that affect FlightGear's main property tree. Other files use the property-file format for convenience to populate various data structures, but they do not touch the main tree and are not accessible through the property browser or through the command-line --prop: option; it's just a coincidence that they also use the property-list format:

* materials.xml - define the materials (textures, colour, lighting) for use in the scenery
* HUDS/**/*.xml - configuration files to define the various heads-up displays
* Aircraft/*/*-sound.xml - configuration files to define sounds played for various aircraft
* Aircraft/*/Panels/*-panel.xml - configuration files to define 2D panels for various aircraft.
* Aircraft/*/Instruments/*.xml - configuration files for individual instruments included by the 2D panels.
* Aircraft/Instruments/*.xml - ditto
* Aircraft/*/Models/*.xml - animation files for a .ac file, oodles of <animation> nodes!

We also use some XML-based formats that do not (yet?) follow the property-list conventions, including the following:

* Aircraft/*/*.xml - JSBSim aero model config files
* Aircraft/Aircraft-yasim/*.xml - YASim aero model config files
* Engine/*.xml - JSBSim engine and thruster config files

YASim and JSBSim each uses its own XML format, which is different from the XML format used by the rest of FlightGear. For YASim, see $FG_ROOT/Aircraft-yasim/README.yasim in the base package; for JSBSim, see the documentation at http://jsbsim.sourceforge.net/. UIUC uses a non-XML config-file format.

The one advantage of Yasim's approach is efficiency -- Andy copies from the XML straight into the YASim data structures, without building up and tearing down an in-memory property tree first. For large-scale XML implementations, we *have* to do things that way -- the DOM and XSLT tend to break down catastrophically for large XML documents or high volume. That's why we designed the Simple API for XML (SAX).

Efficiency doesn't matter much for YASim, since it's a short file and we're reading it only once. If we're ever processing a lot of XML in the main loop, say, over a network connection or from large GIS databases, we'll need to go with a streaming approach like Andy used.

There are several places to look for properties; one is in the aircraft files, another is all Nasal files, and the last place (and often most useful!) is grepping (searching) through the C++ code. To determine how a property works and what it does often requires looking through any code that uses it. This is a part of FlightGear that we could certainly document better.

As for the relationship between XML and the Property Tree, in some cases in FG (most notably preferences.xml and each AIRCRAFT-set.xml file), the <PropertyList> format directly defines properties in FlightGear's global property tree. In other cases, like the animation files given by /sim/model/path, those do not define properties but the <PropertyList> format is used as a matter of convenience so that FG can parse all of its XML files using the same mechanism and to keep the fundamental structure the same. XML has a lot of different dialects, and having only one for FlightGear really makes it easier, especially since it is very intuitive

== Related content ==
=== Wiki articles ===
* [[Conditions]] – Sometimes things can be made conditional on other properties
* [[Expressions]] – Sometimes mathematical expressions can be used

=== Readme files ===
* {{readme file|introduction}}
* {{readme file|properties}}
* {{readme file|xmlsyntax}} – XML in 15 minutes or less
* {{readme file|xmlpanel}} – Contains valuable information on the PropertyList format

=== Forum ===
* http://forum.flightgear.org/viewtopic.php?f=18&t=19503

=== Developer mailing list ===
* {{cite web |url=http://sourceforge.net/p/flightgear/mailman/flightgear-devel/thread/4E79A5CC.80906@t3r.de/ |title=<nowiki>[</nowiki>Flightgear-devel<nowiki>]</nowiki> Property Tree Question: How to save an aircraft specific property between sessions.}}

[[Category:XML]]
[[Category:Property Tree]]

PropertyList XML files

2022-01-12T09:25:15Z

MariuszXC: /* Aliased properties */ - corrected xml closing tag

{{PropertyTree}}

Most configuration files in FlightGear are '''PropertyList XML files''' using a subset of XML to encode lists and trees of [[Property Tree Intro|properties]] as XML. PropertyList-XML files are the main mechanism to populate the FlightGear property tree (or a sub branch of it) from XML files, but also to serialize (save) property tree/branch state to an XML file. XML attributes are mainly used as meta-directives for the property tree.

{{Note|
{{FGCquote
|any --prop: argument can be just as well added to preferences.xml<br/>
For that, you only need to understand how properties are mapped to XML space and vice versa:
<syntaxhighlight lang="xml">
<sim>
<foo n="0">teddy</foo>
<foo n="1">tiger</foo>
</sim>
</syntaxhighlight>these can be expressed using <nowiki>--prop:/sim/foo[0]=teddy and --prop:/sim/foo[1]=tiger</nowiki>
You should however not edit $FG_ROOT/preferences.xml directly - which should be considered readonly, instead, use $FG_HOME, which will be treated as an overlay (on top of $FG_ROOT/preferences.xml).
|{{cite web |url=http://forum.flightgear.org/viewtopic.php?p=234298#p234298
|title=<nowiki>Re: Command line arguments with 3.4 launcher?</nowiki>
|author=<nowiki>Hooray</nowiki>
|date=<nowiki>Fri Mar 06</nowiki>
}}
}}
}}

For additional background information, you'll also want to refer to [[$FG_ROOT]]/Docs/README.introduction.

== Advantages ==
One advantage of the XML representation is its conceptual simplicity. Every element except for the root PropertyList container represents exactly one property, and every attribute represents metadata for the property associated with its element.

To work with PropertyList-XML files, you can use various means, such as:
* fgcommands
* Nasal (props.nas, io.nas)
* C++ APIs (see links at the end of the navigation sidebar)
* Text editor: manually edit XML files

Right now, we use attributes for meta-information (data type, read/write flags, aliasing, and tracing). As long as we use attributes for meta-information and elements for data, we'll have a clean upgrade path; otherwise, we could end up with lots of reserved names (like you could not have a property named "alias", for example, because it would conflict with the attribute), and versioning problems (there's a new attribute named "foo", so any existing "foo" properties have to be renamed).

The current practice is a little verbose compared with a custom-designed, single-purpose XML format, but it generalizes nicely. Another alternative would be to use XML Namespaces, but (while I support them) those have their detractors even in the hard-core XML community, and I'm worried that they'll confuse people a bit in FlightGear.

A custom-designed XML format for panels, sound, animations, FDMs, etc. could be *much* less verbose, but then we'd be managing n different XML-based formats and parsing libraries.

== Read and write access ==
{{IO Restrictions}}

== The PropertyList format ==
The root element of each file is always named <PropertyList>. Tags are almost always found in pairs, with the closing tag having a slash prefixing the tag name, i.e </PropertyList>, just like in any other XML dialect. The exception is the tag representing an aliased property. In this case a slash is prepended to the closing angle bracket:

<syntaxhighlight lang="xml">
<prop alias="/sim/foo"/>
</syntaxhighlight>

=== Minimal example ===
A minimal example of a complete property list encoded XML file, looks like this:

<syntaxhighlight lang="xml">
<?xml version="1.0" encoding="UTF-8"?>

<PropertyList>
</PropertyList>
</syntaxhighlight>

=== Property node tags and attributes ===
Each node in a tree is specified using a single tag that can take attributes describing various things about it:

<syntaxhighlight lang="xml">
<?xml version="1.0" encoding="UTF-8"?>
<PropertyList>
<welcome type="string">Welcome to FlightGear! This is a string as a property</welcome>
</PropertyList>
</syntaxhighlight>

=== Property type attributes ===
Property typing is optional, all properties are by default string/unspecified and are transparently converted by the property tree, but it never hurts, especially when including spaces around numbers:

<syntaxhighlight lang="xml">
<?xml version="1.0" encoding="UTF-8"?>
<PropertyList>
<foo type="string">Hello</foo>
<pi type="float"> 3.14 </pi>
<boo type="bool">true</boo>
</PropertyList>
</syntaxhighlight>

=== Indexed nodes ===
Indexing happens implicitly for identically named properties:

<syntaxhighlight lang="xml">
<?xml version="1.0" encoding="UTF-8"?>
<PropertyList>
<foo>Hello</foo>
<foo>Hello</foo>
<foo>Hello</foo>
</PropertyList>
</syntaxhighlight>

so that the three foo tags become foo[0], foo[1], foo[2] in the property tree, but you can also use explicit indexing by setting the '''n''' attribute of each tag:

<syntaxhighlight lang="xml">
<?xml version="1.0" encoding="UTF-8"?>
<PropertyList>
<foo n="0">Hello</foo>
<foo n="1">Hello</foo>
<foo n="2">Hello</foo>
</PropertyList>
</syntaxhighlight>

Though the above two examples are equivalent, we tend often to include "n" anyway, just to help people keep track of where they are. That's most important when there are a lot of subproperties, not in a simple list like the above.

=== Archived properties ===
To make property settings persistent in between FlightGear sessions, use the userarchive attribute:

<syntaxhighlight lang="xml">
<?xml version="1.0" encoding="UTF-8"?>
<PropertyList>
<foo userarchive="y">Hello</foo>
</PropertyList>
</syntaxhighlight>

=== Including external PropertyList files ===
We can also create new PropertyList files by subtyping existing ones using the include attribute. For example, if someone made a DC-3 model for JSBSim, we could subclass from the YASim config file like this:

<syntaxhighlight lang="xml">
<?xml version="1.0" encoding="UTF-8"?>
<PropertyList include="dc3-yasim-set.xml">
<sim>
<description>DC-3 (JSBSim).</description>
<flight-model archive="y">jsb</flight-model>
</sim>
</PropertyList>
</syntaxhighlight>

Emmanuel Baranger's models tend to use this technique lot and often have several XML files: the first (the -set.xml) contains very basic information, often just author and version number, and includes the next; the second is for FDM-specific properties (the -yasim-cnf or -jsbsim-cnf); and the last has FDM-independent things like flap settings (the -base.xml). This structuring allows for maximum reusability between FDMs and makes it easier for someone to come along and add another FDM to a model.

{{Caution|The 'new' vec*d types are not fully/propertly integrated with the underlying PropertyTree APIs yet, which means that some things may not work as expected, which is particularly important when dealing with files using those types (e.g. effects - see below for details).
{{FGCquote
|Instead of:
<syntaxhighlight lang="xml">
<effect include="Aircraft/f16/Models/Effects/glass/glass.xml"/>
</syntaxhighlight>
It is best to use
<syntaxhighlight lang="xml">
<effect>
<inherits-from>Aircraft/f16/Models/Effects/glass/glass</inherits-from><br/>
</effect>
</syntaxhighlight>
|{{cite web |url=http://sourceforge.net/p/flightgear/mailman/message/33606423/
|title=<nowiki>Re: [Flightgear-devel] xml: Unrecognized data type 'vec3d (Was:
Cockpit glass effect)</nowiki>
|author=<nowiki>Erik Hofman</nowiki>
|date=<nowiki>2015-03-17</nowiki>
}}
}}
}}

=== Aliased properties ===
Properties can alias other properties, in a similar way to symbolic links in Unix. When one of them changes the other one changes as well.

For example, this

<syntaxhighlight lang="xml">
<?xml version="1.0" encoding="UTF-8"?>
<PropertyList>
<foo>46</foo>
<bar alias="/foo"/>
</PropertyList>
</syntaxhighlight>

will be functionally identical to

<syntaxhighlight lang="xml">
<?xml version="1.0" encoding="UTF-8"?>
<PropertyList>
<foo>46</foo>
<bar>46</bar>
</PropertyList>
</syntaxhighlight>

except that bar and foo will always be identical.

A PropertyList file can begin with a property subtree that are aliased later in the file.

<syntaxhighlight lang="xml">
<?xml version="1.0" encoding="UTF-8"?>
<PropertyList>
<params>
<comm-freq-prop>/radios/comm1/frequencies/selected</comm-freq-prop>
<nav-freq-prop>/radios/nav1/frequencies/selected</nav-freq-prop>
</params>
<chunk>
<type>number-value</type>
<property alias="/params/nav-freq-prop"/>
</chunk>
</PropertyList>
</syntaxhighlight>

=== Aliasing combined with inclusion ===
The combination of aliasing and inclusion allows for parameterization, which can be of great help both for debugging and mainenance. The above example could for example instead be split up into

<syntaxhighlight lang="xml">
<?xml version="1.0" encoding="UTF-8"?>
<PropertyList>
<params>
<comm-freq-prop>/radios/comm1/frequencies/selected</comm-freq-prop>
<nav-freq-prop>/radios/nav1/frequencies/selected</comm-freq-prop>
</params>
</PropertyList>
</syntaxhighlight>

and

<syntaxhighlight lang="xml">
<?xml version="1.0" encoding="UTF-8"?>
<PropertyList>
<params include="MyParams.xml"/>
<chunk>
<type>number-value</type>
<property alias="/params/nav-freq-prop"/>
</chunk>
</PropertyList>
</syntaxhighlight>

The parameters can be overridden at inclusion

<syntaxhighlight lang="xml">
<?xml version="1.0" encoding="UTF-8"?>
<PropertyList>
<instrument include="../Instruments/navcomm.xml">
<params>
<comm-freq-prop>/radios/comm1/frequencies/selected</comm-freq-prop>
<nav-freq-prop>/radios/nav1/frequencies/selected</comm-freq-prop>
</params>
</instrument>
</PropertyList>
</syntaxhighlight>

<syntaxhighlight lang="xml">
<?xml version="1.0" encoding="UTF-8"?>
<PropertyList>
<instrument include="../Instruments/navcomm.xml">
<params>
<comm-freq-prop>/radios/comm2/frequencies/selected</comm-freq-prop>
<nav-freq-prop>/radios/nav2/frequencies/selected</comm-freq-prop>
</params>
</instrument>
</PropertyList>
</syntaxhighlight>

== CDATA ==
Whenever you need to embed text that isn't valid XML, because it may contain XML tokens, you need to wrap the whole section in a CDATA section, this is typically done with [[Nasal]] code, so that it doesn't need to escape XML entities:

<syntaxhighlight lang="xml">
<?xml version="1.0" encoding="UTF-8"?>
<PropertyList>
<nasal>
<![CDATA[
# begin of code
print("\n");
# end of code
]]>
</nasal>
</PropertyList>

</syntaxhighlight>

Note how the CDATA section now contains tokens/characters that would otherwise make the XML markup invalid.

== PropertyList-based configuration files ==
Not everything that is read from an XML file resides in the main property tree; some subsystems also use XML files for initial configuration information and are read into a temporary tree and subsequently discarded. The main property tree is meant to represent the shared state of the program, but when a subsystem happens to use an XML file to set up its internal state that information is ofteb of no use to the rest of the program and thus does not need to continually be in the main tree. Temporary trees are usually deleted as soon as the subsystem is set up (i.e. they exist for perhaps 0.1 sec). We could just as easily use another format for internal initialization, but since the XML support is already available, it was the easiest route.

The config files serve many different purposes; using the XML-based property-list format for all of them helps a lot, since it allows some common structure and reusable code among all the formats. Imagine if we had one file format for preferences, a different one for panels (say, with fixed-length fields), a different one for saving a flight (perhaps a binary format), another one for sound configuration (perhaps an INI file), a different one for top-level aircraft configuration (perhaps CSV), yet another one for configuring 3D models (perhaps embedded data strings in the 3D files themselves), etc. etc.

We have config files for totally different purposes, and the fact that they all use XML is simply a convenience for programmers and customizers.
Here are some of the conventions that we've come up with so far, partly ad-hoc (all paths relative to $FG_ROOT):

* preferences.xml - the top-level default preferences
* joysticks.xml - default joystick bindings, included by preferences.xml
* keyboard.xml - default keyboard bindings, included by preferences.xml
* Aircraft/*-set.xml - aircraft-specific settings, overriding the defaults in preferences.xml (and joystick/keyboard.xml)

Basically, these are the main files in the base package that affect FlightGear's main property tree. Other files use the property-file format for convenience to populate various data structures, but they do not touch the main tree and are not accessible through the property browser or through the command-line --prop: option; it's just a coincidence that they also use the property-list format:

* materials.xml - define the materials (textures, colour, lighting) for use in the scenery
* HUDS/**/*.xml - configuration files to define the various heads-up displays
* Aircraft/*/*-sound.xml - configuration files to define sounds played for various aircraft
* Aircraft/*/Panels/*-panel.xml - configuration files to define 2D panels for various aircraft.
* Aircraft/*/Instruments/*.xml - configuration files for individual instruments included by the 2D panels.
* Aircraft/Instruments/*.xml - ditto
* Aircraft/*/Models/*.xml - animation files for a .ac file, oodles of <animation> nodes!

We also use some XML-based formats that do not (yet?) follow the property-list conventions, including the following:

* Aircraft/*/*.xml - JSBSim aero model config files
* Aircraft/Aircraft-yasim/*.xml - YASim aero model config files
* Engine/*.xml - JSBSim engine and thruster config files

YASim and JSBSim each uses its own XML format, which is different from the XML format used by the rest of FlightGear. For YASim, see $FG_ROOT/Aircraft-yasim/README.yasim in the base package; for JSBSim, see the documentation at http://jsbsim.sourceforge.net/. UIUC uses a non-XML config-file format.

The one advantage of Yasim's approach is efficiency -- Andy copies from the XML straight into the YASim data structures, without building up and tearing down an in-memory property tree first. For large-scale XML implementations, we *have* to do things that way -- the DOM and XSLT tend to break down catastrophically for large XML documents or high volume. That's why we designed the Simple API for XML (SAX).

Efficiency doesn't matter much for YASim, since it's a short file and we're reading it only once. If we're ever processing a lot of XML in the main loop, say, over a network connection or from large GIS databases, we'll need to go with a streaming approach like Andy used.

There are several places to look for properties; one is in the aircraft files, another is all Nasal files, and the last place (and often most useful!) is grepping (searching) through the C++ code. To determine how a property works and what it does often requires looking through any code that uses it. This is a part of FlightGear that we could certainly document better.

As for the relationship between XML and the Property Tree, in some cases in FG (most notably preferences.xml and each AIRCRAFT-set.xml file), the <PropertyList> format directly defines properties in FlightGear's global property tree. In other cases, like the animation files given by /sim/model/path, those do not define properties but the <PropertyList> format is used as a matter of convenience so that FG can parse all of its XML files using the same mechanism and to keep the fundamental structure the same. XML has a lot of different dialects, and having only one for FlightGear really makes it easier, especially since it is very intuitive

== Related content ==
=== Wiki articles ===
* [[Conditions]] – Sometimes things can be made conditional on other properties
* [[Expressions]] – Sometimes mathematical expressions can be used

=== Readme files ===
* {{readme file|introduction}}
* {{readme file|properties}}
* {{readme file|xmlsyntax}} – XML in 15 minutes or less
* {{readme file|xmlpanel}} – Contains valuable information on the PropertyList format

=== Forum ===
* http://forum.flightgear.org/viewtopic.php?f=18&t=19503

=== Developer mailing list ===
* {{cite web |url=http://sourceforge.net/p/flightgear/mailman/flightgear-devel/thread/4E79A5CC.80906@t3r.de/ |title=<nowiki>[</nowiki>Flightgear-devel<nowiki>]</nowiki> Property Tree Question: How to save an aircraft specific property between sessions.}}

[[Category:XML]]
[[Category:Property Tree]]

OpenGL performance

2022-01-09T18:39:06Z

MariuszXC: added more benchmarks

== OpenGL performance ==
OpenGL performance can be tested using glmark2 program. It is available in most Linux distributions. In Debian derived distributions (like Ubuntu) it can be installed by issuing ''sudo apt install glmark2'' from command line.

The data presented below was taken by running ''glmark2'' without any additional options, i.e. with default settings, on an otherwise idle system.

By comparing your results with measurements taken on other similar systems you can verify if your hardware and software combination is performing as expected.

=== Integrated graphics ===
==== Intel i5-4310M @ 2.70 GHz (integrated Intel HD 4600 GPU) ====

'''glmark2 Score: 1668'''

{{collapsible script
| type = details
| title = (click show to expand)
| lang = text
| script = ----
glmark2 2014.03+git20150611.fa71af2d
----
OpenGL Information
GL_VENDOR: Intel Open Source Technology Center
GL_RENDERER: Mesa DRI Intel(R) Haswell Mobile
GL_VERSION: 3.0 Mesa 18.0.5
----
<pre>
[build] use-vbo=false: FPS: 2256 FrameTime: 0.443 ms
[build] use-vbo=true: FPS: 2500 FrameTime: 0.400 ms
[texture] texture-filter=nearest: FPS: 2183 FrameTime: 0.458 ms
[texture] texture-filter=linear: FPS: 2180 FrameTime: 0.459 ms
[texture] texture-filter=mipmap: FPS: 2250 FrameTime: 0.444 ms
[shading] shading=gouraud: FPS: 2042 FrameTime: 0.490 ms
[shading] shading=blinn-phong-inf: FPS: 2049 FrameTime: 0.488 ms
[shading] shading=phong: FPS: 1938 FrameTime: 0.516 ms
[shading] shading=cel: FPS: 2037 FrameTime: 0.491 ms
[bump] bump-render=high-poly: FPS: 1701 FrameTime: 0.588 ms
[bump] bump-render=normals: FPS: 2419 FrameTime: 0.413 ms
[bump] bump-render=height: FPS: 2382 FrameTime: 0.420 ms
[effect2d] kernel=0,1,0;1,-4,1;0,1,0;: FPS: 1758 FrameTime: 0.569 ms
[effect2d] kernel=1,1,1,1,1;1,1,1,1,1;1,1,1,1,1;: FPS: 886 FrameTime: 1.129 ms
[pulsar] light=false:quads=5:texture=false: FPS: 2008 FrameTime: 0.498 ms
[desktop] blur-radius=5:effect=blur:passes=1:separable=true:windows=4: FPS: 749 FrameTime: 1.335 ms
[desktop] effect=shadow:windows=4: FPS: 1094 FrameTime: 0.914 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 770 FrameTime: 1.299 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=subdata: FPS: 655 FrameTime: 1.527 ms
[buffer] columns=200:interleave=true:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 857 FrameTime: 1.167 ms
[ideas] speed=duration: FPS: 1776 FrameTime: 0.563 ms
[jellyfish] <default>: FPS: 1275 FrameTime: 0.784 ms
[terrain] <default>: FPS: 173 FrameTime: 5.780 ms
[shadow] <default>: FPS: 805 FrameTime: 1.242 ms
[refract] <default>: FPS: 268 FrameTime: 3.731 ms
[conditionals] fragment-steps=0:vertex-steps=0: FPS: 2038 FrameTime: 0.491 ms
[conditionals] fragment-steps=5:vertex-steps=0: FPS: 2039 FrameTime: 0.490 ms
[conditionals] fragment-steps=0:vertex-steps=5: FPS: 2028 FrameTime: 0.493 ms
[function] fragment-complexity=low:fragment-steps=5: FPS: 2037 FrameTime: 0.491 ms
[function] fragment-complexity=medium:fragment-steps=5: FPS: 2051 FrameTime: 0.488 ms
[loop] fragment-loop=false:fragment-steps=5:vertex-steps=5: FPS: 1879 FrameTime: 0.532 ms
[loop] fragment-steps=5:fragment-uniform=false:vertex-steps=5: FPS: 1922 FrameTime: 0.520 ms
[loop] fragment-steps=5:fragment-uniform=true:vertex-steps=5: FPS: 2039 FrameTime: 0.490 ms</pre>
}}

==== Intel i5-6200U @ 2.3 GHz (integrated Intel UHD 620 GPU) ====
Remark: CPU clock boosted to 2.8 GHz during benchmarking

'''glmark2 Score: 1294'''

{{collapsible script
| type = details
| title = (click show to expand)
| lang = text
| script = ----
glmark2 2021.02
----
OpenGL Information
GL_VENDOR: Intel
GL_RENDERER: Mesa Intel(R) HD Graphics 520 (SKL GT2)
GL_VERSION: 4.6 (Compatibility Profile) Mesa 21.0.3
----
[build] use-vbo=false: FPS: 1500 FrameTime: 0.667 ms
[build] use-vbo=true: FPS: 1959 FrameTime: 0.510 ms
[texture] texture-filter=nearest: FPS: 1722 FrameTime: 0.581 ms
[texture] texture-filter=linear: FPS: 1736 FrameTime: 0.576 ms
[texture] texture-filter=mipmap: FPS: 1673 FrameTime: 0.598 ms
[shading] shading=gouraud: FPS: 1584 FrameTime: 0.631 ms
[shading] shading=blinn-phong-inf: FPS: 1554 FrameTime: 0.644 ms
[shading] shading=phong: FPS: 1559 FrameTime: 0.641 ms
[shading] shading=cel: FPS: 1571 FrameTime: 0.637 ms
[bump] bump-render=high-poly: FPS: 1123 FrameTime: 0.890 ms
[bump] bump-render=normals: FPS: 1945 FrameTime: 0.514 ms
[bump] bump-render=height: FPS: 1881 FrameTime: 0.532 ms
[effect2d] kernel=0,1,0;1,-4,1;0,1,0;: FPS: 1359 FrameTime: 0.736 ms
[effect2d] kernel=1,1,1,1,1;1,1,1,1,1;1,1,1,1,1;: FPS: 851 FrameTime: 1.175 ms
[pulsar] light=false:quads=5:texture=false: FPS: 1646 FrameTime: 0.608 ms
[desktop] blur-radius=5:effect=blur:passes=1:separable=true:windows=4: FPS: 757 FrameTime: 1.321 ms
[desktop] effect=shadow:windows=4: FPS: 1094 FrameTime: 0.914 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 585 FrameTime: 1.709 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=subdata: FPS: 529 FrameTime: 1.890 ms
[buffer] columns=200:interleave=true:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 669 FrameTime: 1.495 ms
[ideas] speed=duration: FPS: 1489 FrameTime: 0.672 ms
[jellyfish] <default>: FPS: 1236 FrameTime: 0.809 ms
[terrain] <default>: FPS: 188 FrameTime: 5.319 ms
[shadow] <default>: FPS: 1014 FrameTime: 0.986 ms
[refract] <default>: FPS: 356 FrameTime: 2.809 ms
[conditionals] fragment-steps=0:vertex-steps=0: FPS: 1360 FrameTime: 0.735 ms
[conditionals] fragment-steps=5:vertex-steps=0: FPS: 1407 FrameTime: 0.711 ms
[conditionals] fragment-steps=0:vertex-steps=5: FPS: 1393 FrameTime: 0.718 ms
[function] fragment-complexity=low:fragment-steps=5: FPS: 1412 FrameTime: 0.708 ms
[function] fragment-complexity=medium:fragment-steps=5: FPS: 1416 FrameTime: 0.706 ms
[loop] fragment-loop=false:fragment-steps=5:vertex-steps=5: FPS: 1369 FrameTime: 0.730 ms
[loop] fragment-steps=5:fragment-uniform=false:vertex-steps=5: FPS: 1388 FrameTime: 0.720 ms
[loop] fragment-steps=5:fragment-uniform=true:vertex-steps=5: FPS: 1383 FrameTime: 0.723 ms
}}

=== Discrete graphics card ===
Note: this section also contains hybrid configurations (e.g. laptops with dual GPU technology)

==== AMD FirePro M5950 + Intel i5-2520M ====
Remark: dual GPU technology laptop, no test details available.

'''glmark2 Score: 5600'''

==== NVIDIA RTX2060 6GB + AMD Ryzen 7 3700X 8-Core 4GHz ====
Note that some tests resulted in errors and finally a core dump, so there is no final glmark2 Score.

{{collapsible script
| type = details
| title = (click show to expand)
| lang = text
| script =----
glmark2 2021.02
----
OpenGL Information
GL_VENDOR: NVIDIA Corporation
GL_RENDERER: NVIDIA GeForce RTX 2060/PCIe/SSE2
GL_VERSION: 4.6.0 NVIDIA 495.46
----
<pre>
[build] use-vbo=false: FPS: 13809 FrameTime: 0.072 ms
[build] use-vbo=true: FPS: 28367 FrameTime: 0.035 ms
[texture] texture-filter=nearest: FPS: 27958 FrameTime: 0.036 ms
[texture] texture-filter=linear: FPS: 28120 FrameTime: 0.036 ms
[texture] texture-filter=mipmap: FPS: 28036 FrameTime: 0.036 ms
[shading] shading=gouraud: FPS: 26428 FrameTime: 0.038 ms
[shading] shading=blinn-phong-inf: FPS: 26320 FrameTime: 0.038 ms
[shading] shading=phong: FPS: 25800 FrameTime: 0.039 ms
[shading] shading=cel: FPS: 25498 FrameTime: 0.039 ms
[bump] bump-render=high-poly: FPS: 20696 FrameTime: 0.048 ms
[bump] bump-render=normals: FPS: 29599 FrameTime: 0.034 ms
Error: Failed to add fragment shader from file None:
Error: 0(15) : error C0000: syntax error, unexpected identifier, expecting "::" at token "highp"
Error: 0(36) : warning C1503: undefined variable "TextureCoord"
Error: 0(37) : warning C1503: undefined variable "TextureCoord"
Error: 0(38) : warning C1503: undefined variable "TextureCoord"
Error:
[bump] bump-render=height: Set up failed
[effect2d] kernel=0,1,0;1,-4,1;0,1,0;: FPS: 22140 FrameTime: 0.045 ms
[effect2d] kernel=1,1,1,1,1;1,1,1,1,1;1,1,1,1,1;: FPS: 15018 FrameTime: 0.067 ms
[pulsar] light=false:quads=5:texture=false: FPS: 27482 FrameTime: 0.036 ms
[desktop] blur-radius=5:effect=blur:passes=1:separable=true:windows=4: FPS: 8226 FrameTime: 0.122 ms
[desktop] effect=shadow:windows=4: FPS: 10260 FrameTime: 0.097 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 1490 FrameTime: 0.671 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=subdata: FPS: 1613 FrameTime: 0.620 ms
[buffer] columns=200:interleave=true:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 2147 FrameTime: 0.466 ms
[ideas] speed=duration: FPS: 14164 FrameTime: 0.071 ms
[jellyfish] <default>: FPS: 20591 FrameTime: 0.049 ms
Error: Failed to add fragment shader from file None:
Error: 0(26) : warning C7022: unrecognized profile specifier "highp"
Error: 0(26) : error C0502: syntax error at token "highp"
Error:
Error: Failed to add fragment shader from file None:
Error: 0(75) : warning C7022: unrecognized profile specifier "highp"
Error: 0(75) : error C0502: syntax error at token "highp"
Error:
[terrain] <default>:Segmentation fault (core dumped)</pre>
----
}}

==== AMD Tahiti XT [Radeon HD 7970 / R9 280X] + Intel Core i5-11600K @ 3.90GHz ====

'''glmark2 Score: 13781'''

{{collapsible script
| type = details
| title = (click show to expand)
| lang = text
| script = ----
glmark2 2021.02
----
OpenGL Information
GL_VENDOR: AMD
GL_RENDERER: AMD TAHITI (DRM 2.50.0, 5.11.0-44-generic, LLVM 12.0.0)
GL_VERSION: 4.5 (Compatibility Profile) Mesa 21.0.3
----
[build] use-vbo=false: FPS: 12290 FrameTime: 0.081 ms
[build] use-vbo=true: FPS: 19086 FrameTime: 0.052 ms
[texture] texture-filter=nearest: FPS: 18131 FrameTime: 0.055 ms
[texture] texture-filter=linear: FPS: 18165 FrameTime: 0.055 ms
[texture] texture-filter=mipmap: FPS: 18563 FrameTime: 0.054 ms
[shading] shading=gouraud: FPS: 16185 FrameTime: 0.062 ms
[shading] shading=blinn-phong-inf: FPS: 16135 FrameTime: 0.062 ms
[shading] shading=phong: FPS: 16042 FrameTime: 0.062 ms
[shading] shading=cel: FPS: 16036 FrameTime: 0.062 ms
[bump] bump-render=high-poly: FPS: 9338 FrameTime: 0.107 ms
[bump] bump-render=normals: FPS: 19774 FrameTime: 0.051 ms
[bump] bump-render=height: FPS: 19534 FrameTime: 0.051 ms
[effect2d] kernel=0,1,0;1,-4,1;0,1,0;: FPS: 15477 FrameTime: 0.065 ms
[effect2d] kernel=1,1,1,1,1;1,1,1,1,1;1,1,1,1,1;: FPS: 10139 FrameTime: 0.099 ms
[pulsar] light=false:quads=5:texture=false: FPS: 16858 FrameTime: 0.059 ms
[desktop] blur-radius=5:effect=blur:passes=1:separable=true:windows=4: FPS: 5961 FrameTime: 0.168 ms
[desktop] effect=shadow:windows=4: FPS: 9994 FrameTime: 0.100 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 2577 FrameTime: 0.388 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=subdata: FPS: 3585 FrameTime: 0.279 ms
[buffer] columns=200:interleave=true:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 3158 FrameTime: 0.317 ms
[ideas] speed=duration: FPS: 11924 FrameTime: 0.084 ms
[jellyfish] <default>: FPS: 12073 FrameTime: 0.083 ms
[terrain] <default>: FPS: 1350 FrameTime: 0.741 ms
[shadow] <default>: FPS: 9986 FrameTime: 0.100 ms
[refract] <default>: FPS: 2500 FrameTime: 0.400 ms
[conditionals] fragment-steps=0:vertex-steps=0: FPS: 18815 FrameTime: 0.053 ms
[conditionals] fragment-steps=5:vertex-steps=0: FPS: 18705 FrameTime: 0.053 ms
[conditionals] fragment-steps=0:vertex-steps=5: FPS: 18787 FrameTime: 0.053 ms
[function] fragment-complexity=low:fragment-steps=5: FPS: 18759 FrameTime: 0.053 ms
[function] fragment-complexity=medium:fragment-steps=5: FPS: 18691 FrameTime: 0.054 ms
[loop] fragment-loop=false:fragment-steps=5:vertex-steps=5: FPS: 18755 FrameTime: 0.053 ms
[loop] fragment-steps=5:fragment-uniform=false:vertex-steps=5: FPS: 18759 FrameTime: 0.053 ms
[loop] fragment-steps=5:fragment-uniform=true:vertex-steps=5: FPS: 18654 FrameTime: 0.054 ms
}}

==== NVIDIA GTX-1060 6GB + AMD R7 3700X @ 4.2 GHz, 8 cores, HT off ====

'''glmark2 Score: 20641'''

{{collapsible script
| type = details
| title = (click show to expand)
| lang = text
| script = ----
glmark2 2014.03+git20150611.fa71af2d
----
OpenGL Information
GL_VENDOR: NVIDIA Corporation
GL_RENDERER: GeForce GTX 1060 6GB/PCIe/SSE2
GL_VERSION: 4.6.0 NVIDIA 460.91.03
----
[build] use-vbo=false: FPS: 15192 FrameTime: 0.066 ms
[build] use-vbo=true: FPS: 30325 FrameTime: 0.033 ms
[texture] texture-filter=nearest: FPS: 27634 FrameTime: 0.036 ms
[texture] texture-filter=linear: FPS: 27511 FrameTime: 0.036 ms
[texture] texture-filter=mipmap: FPS: 28397 FrameTime: 0.035 ms
[shading] shading=gouraud: FPS: 26079 FrameTime: 0.038 ms
[shading] shading=blinn-phong-inf: FPS: 25796 FrameTime: 0.039 ms
[shading] shading=phong: FPS: 25060 FrameTime: 0.040 ms
[shading] shading=cel: FPS: 25321 FrameTime: 0.039 ms
[bump] bump-render=high-poly: FPS: 17451 FrameTime: 0.057 ms
[bump] bump-render=normals: FPS: 31963 FrameTime: 0.031 ms
[bump] bump-render=height: FPS: 31608 FrameTime: 0.032 ms
[effect2d] kernel=0,1,0;1,-4,1;0,1,0;: FPS: 20418 FrameTime: 0.049 ms
[effect2d] kernel=1,1,1,1,1;1,1,1,1,1;1,1,1,1,1;: FPS: 12585 FrameTime: 0.079 ms
[pulsar] light=false:quads=5:texture=false: FPS: 28174 FrameTime: 0.035 ms
[desktop] blur-radius=5:effect=blur:passes=1:separable=true:windows=4: FPS: 7331 FrameTime: 0.136 ms
[desktop] effect=shadow:windows=4: FPS: 14034 FrameTime: 0.071 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 2363 FrameTime: 0.423 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=subdata: FPS: 2783 FrameTime: 0.359 ms
[buffer] columns=200:interleave=true:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 2330 FrameTime: 0.429 ms
[ideas] speed=duration: FPS: 19421 FrameTime: 0.051 ms
[jellyfish] <default>: FPS: 17291 FrameTime: 0.058 ms
[terrain] <default>: FPS: 1349 FrameTime: 0.741 ms
[shadow] <default>: FPS: 15688 FrameTime: 0.064 ms
[refract] <default>: FPS: 4783 FrameTime: 0.209 ms
[conditionals] fragment-steps=0:vertex-steps=0: FPS: 28599 FrameTime: 0.035 ms
[conditionals] fragment-steps=5:vertex-steps=0: FPS: 27499 FrameTime: 0.036 ms
[conditionals] fragment-steps=0:vertex-steps=5: FPS: 28191 FrameTime: 0.035 ms
[function] fragment-complexity=low:fragment-steps=5: FPS: 27695 FrameTime: 0.036 ms
[function] fragment-complexity=medium:fragment-steps=5: FPS: 26605 FrameTime: 0.038 ms
[loop] fragment-loop=false:fragment-steps=5:vertex-steps=5: FPS: 27340 FrameTime: 0.037 ms
[loop] fragment-steps=5:fragment-uniform=false:vertex-steps=5: FPS: 27361 FrameTime: 0.037 ms
[loop] fragment-steps=5:fragment-uniform=true:vertex-steps=5: FPS: 26984 FrameTime: 0.037 ms
}}

==== NVIDIA Quadro K1000M 1GB + Intel Core i7-3610Q @ 2.3 GHz ====
Remark: during glmark2 testing CPU clock boosted to 3.3 GHz

''' glmark2 Score: 2754 '''

{{collapsible script
| type = details
| title = (click show to expand)
| lang = text
| script = ----
glmark2 2014.03+git20150611.fa71af2d
----
OpenGL Information
GL_VENDOR: NVIDIA Corporation
GL_RENDERER: Quadro K1000M/PCIe/SSE2
GL_VERSION: 4.6.0 NVIDIA 390.138
----
[build] use-vbo=false: FPS: 4154 FrameTime: 0.241 ms
[build] use-vbo=true: FPS: 4205 FrameTime: 0.238 ms
[texture] texture-filter=nearest: FPS: 3791 FrameTime: 0.264 ms
[texture] texture-filter=linear: FPS: 3718 FrameTime: 0.269 ms
[texture] texture-filter=mipmap: FPS: 3761 FrameTime: 0.266 ms
[shading] shading=gouraud: FPS: 3187 FrameTime: 0.314 ms
[shading] shading=blinn-phong-inf: FPS: 3200 FrameTime: 0.312 ms
[shading] shading=phong: FPS: 3078 FrameTime: 0.325 ms
[shading] shading=cel: FPS: 3065 FrameTime: 0.326 ms
[bump] bump-render=high-poly: FPS: 1674 FrameTime: 0.597 ms
[bump] bump-render=normals: FPS: 4329 FrameTime: 0.231 ms
[bump] bump-render=height: FPS: 4174 FrameTime: 0.240 ms
[effect2d] kernel=0,1,0;1,-4,1;0,1,0;: FPS: 2356 FrameTime: 0.424 ms
[effect2d] kernel=1,1,1,1,1;1,1,1,1,1;1,1,1,1,1;: FPS: 1249 FrameTime: 0.801 ms
[pulsar] light=false:quads=5:texture=false: FPS: 3550 FrameTime: 0.282 ms
[desktop] blur-radius=5:effect=blur:passes=1:separable=true:windows=4: FPS: 888 FrameTime: 1.126 ms
[desktop] effect=shadow:windows=4: FPS: 1453 FrameTime: 0.688 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 952 FrameTime: 1.050 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=subdata: FPS: 1277 FrameTime: 0.783 ms
[buffer] columns=200:interleave=true:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 977 FrameTime: 1.024 ms
[ideas] speed=duration: FPS: 2926 FrameTime: 0.342 ms
[jellyfish] <default>: FPS: 1551 FrameTime: 0.645 ms
[terrain] <default>: FPS: 173 FrameTime: 5.780 ms
[shadow] <default>: FPS: 2420 FrameTime: 0.413 ms
[refract] <default>: FPS: 431 FrameTime: 2.320 ms
[conditionals] fragment-steps=0:vertex-steps=0: FPS: 3776 FrameTime: 0.265 ms
[conditionals] fragment-steps=5:vertex-steps=0: FPS: 3061 FrameTime: 0.327 ms
[conditionals] fragment-steps=0:vertex-steps=5: FPS: 3776 FrameTime: 0.265 ms
[function] fragment-complexity=low:fragment-steps=5: FPS: 3775 FrameTime: 0.265 ms
[function] fragment-complexity=medium:fragment-steps=5: FPS: 3058 FrameTime: 0.327 ms
[loop] fragment-loop=false:fragment-steps=5:vertex-steps=5: FPS: 3776 FrameTime: 0.265 ms
[loop] fragment-steps=5:fragment-uniform=false:vertex-steps=5: FPS: 3776 FrameTime: 0.265 ms
[loop] fragment-steps=5:fragment-uniform=true:vertex-steps=5: FPS: 3375 FrameTime: 0.296 ms
}}

==== NVIDIA GTX 750 + Intel Core i5-2550K @ 3.4 GHz ====
Remark: no test details available.

'''glmark2 Score: 9000'''

==== NVIDIA GTX 1060 + Intel Core i5-2550K @ 3.4 GHz ====
Remark: no test details available.

'''glmark2 Score: 19000'''

OpenGL performance

2022-01-09T18:25:25Z

MariuszXC: reorganised into sections, added Intel i5-6200U @ 2.3 GHz

== OpenGL performance ==
OpenGL performance can be tested using glmark2 program. It is available in most Linux distributions. In Debian derived distributions (like Ubuntu) it can be installed by issuing ''sudo apt install glmark2'' from command line.

The data presented below was taken by running ''glmark2'' without any additional options, i.e. with default settings, on an otherwise idle system.

By comparing your results with measurements taken on other similar systems you can verify if your hardware and software combination is performing as expected.

=== Integrated graphics ===
==== Intel i5-4310M @ 2.70 GHz (integrated Intel HD 4600 GPU) ====

'''glmark2 Score: 1668'''

{{collapsible script
| type = details
| title = (click show to expand)
| lang = text
| script = ----
glmark2 2014.03+git20150611.fa71af2d
----
OpenGL Information
GL_VENDOR: Intel Open Source Technology Center
GL_RENDERER: Mesa DRI Intel(R) Haswell Mobile
GL_VERSION: 3.0 Mesa 18.0.5
----
<pre>
[build] use-vbo=false: FPS: 2256 FrameTime: 0.443 ms
[build] use-vbo=true: FPS: 2500 FrameTime: 0.400 ms
[texture] texture-filter=nearest: FPS: 2183 FrameTime: 0.458 ms
[texture] texture-filter=linear: FPS: 2180 FrameTime: 0.459 ms
[texture] texture-filter=mipmap: FPS: 2250 FrameTime: 0.444 ms
[shading] shading=gouraud: FPS: 2042 FrameTime: 0.490 ms
[shading] shading=blinn-phong-inf: FPS: 2049 FrameTime: 0.488 ms
[shading] shading=phong: FPS: 1938 FrameTime: 0.516 ms
[shading] shading=cel: FPS: 2037 FrameTime: 0.491 ms
[bump] bump-render=high-poly: FPS: 1701 FrameTime: 0.588 ms
[bump] bump-render=normals: FPS: 2419 FrameTime: 0.413 ms
[bump] bump-render=height: FPS: 2382 FrameTime: 0.420 ms
[effect2d] kernel=0,1,0;1,-4,1;0,1,0;: FPS: 1758 FrameTime: 0.569 ms
[effect2d] kernel=1,1,1,1,1;1,1,1,1,1;1,1,1,1,1;: FPS: 886 FrameTime: 1.129 ms
[pulsar] light=false:quads=5:texture=false: FPS: 2008 FrameTime: 0.498 ms
[desktop] blur-radius=5:effect=blur:passes=1:separable=true:windows=4: FPS: 749 FrameTime: 1.335 ms
[desktop] effect=shadow:windows=4: FPS: 1094 FrameTime: 0.914 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 770 FrameTime: 1.299 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=subdata: FPS: 655 FrameTime: 1.527 ms
[buffer] columns=200:interleave=true:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 857 FrameTime: 1.167 ms
[ideas] speed=duration: FPS: 1776 FrameTime: 0.563 ms
[jellyfish] <default>: FPS: 1275 FrameTime: 0.784 ms
[terrain] <default>: FPS: 173 FrameTime: 5.780 ms
[shadow] <default>: FPS: 805 FrameTime: 1.242 ms
[refract] <default>: FPS: 268 FrameTime: 3.731 ms
[conditionals] fragment-steps=0:vertex-steps=0: FPS: 2038 FrameTime: 0.491 ms
[conditionals] fragment-steps=5:vertex-steps=0: FPS: 2039 FrameTime: 0.490 ms
[conditionals] fragment-steps=0:vertex-steps=5: FPS: 2028 FrameTime: 0.493 ms
[function] fragment-complexity=low:fragment-steps=5: FPS: 2037 FrameTime: 0.491 ms
[function] fragment-complexity=medium:fragment-steps=5: FPS: 2051 FrameTime: 0.488 ms
[loop] fragment-loop=false:fragment-steps=5:vertex-steps=5: FPS: 1879 FrameTime: 0.532 ms
[loop] fragment-steps=5:fragment-uniform=false:vertex-steps=5: FPS: 1922 FrameTime: 0.520 ms
[loop] fragment-steps=5:fragment-uniform=true:vertex-steps=5: FPS: 2039 FrameTime: 0.490 ms</pre>
}}

==== Intel i5-6200U @ 2.3 GHz (integrated Intel UHD 620 GPU) ====
Remark: CPU clock boosted to 2.8 GHz during benchmarking

'''glmark2 Score: 1294'''

{{collapsible script
| type = details
| title = (click show to expand)
| lang = text
| script = ----
glmark2 2021.02
----
OpenGL Information
GL_VENDOR: Intel
GL_RENDERER: Mesa Intel(R) HD Graphics 520 (SKL GT2)
GL_VERSION: 4.6 (Compatibility Profile) Mesa 21.0.3
----
[build] use-vbo=false: FPS: 1500 FrameTime: 0.667 ms
[build] use-vbo=true: FPS: 1959 FrameTime: 0.510 ms
[texture] texture-filter=nearest: FPS: 1722 FrameTime: 0.581 ms
[texture] texture-filter=linear: FPS: 1736 FrameTime: 0.576 ms
[texture] texture-filter=mipmap: FPS: 1673 FrameTime: 0.598 ms
[shading] shading=gouraud: FPS: 1584 FrameTime: 0.631 ms
[shading] shading=blinn-phong-inf: FPS: 1554 FrameTime: 0.644 ms
[shading] shading=phong: FPS: 1559 FrameTime: 0.641 ms
[shading] shading=cel: FPS: 1571 FrameTime: 0.637 ms
[bump] bump-render=high-poly: FPS: 1123 FrameTime: 0.890 ms
[bump] bump-render=normals: FPS: 1945 FrameTime: 0.514 ms
[bump] bump-render=height: FPS: 1881 FrameTime: 0.532 ms
[effect2d] kernel=0,1,0;1,-4,1;0,1,0;: FPS: 1359 FrameTime: 0.736 ms
[effect2d] kernel=1,1,1,1,1;1,1,1,1,1;1,1,1,1,1;: FPS: 851 FrameTime: 1.175 ms
[pulsar] light=false:quads=5:texture=false: FPS: 1646 FrameTime: 0.608 ms
[desktop] blur-radius=5:effect=blur:passes=1:separable=true:windows=4: FPS: 757 FrameTime: 1.321 ms
[desktop] effect=shadow:windows=4: FPS: 1094 FrameTime: 0.914 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 585 FrameTime: 1.709 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=subdata: FPS: 529 FrameTime: 1.890 ms
[buffer] columns=200:interleave=true:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 669 FrameTime: 1.495 ms
[ideas] speed=duration: FPS: 1489 FrameTime: 0.672 ms
[jellyfish] <default>: FPS: 1236 FrameTime: 0.809 ms
[terrain] <default>: FPS: 188 FrameTime: 5.319 ms
[shadow] <default>: FPS: 1014 FrameTime: 0.986 ms
[refract] <default>: FPS: 356 FrameTime: 2.809 ms
[conditionals] fragment-steps=0:vertex-steps=0: FPS: 1360 FrameTime: 0.735 ms
[conditionals] fragment-steps=5:vertex-steps=0: FPS: 1407 FrameTime: 0.711 ms
[conditionals] fragment-steps=0:vertex-steps=5: FPS: 1393 FrameTime: 0.718 ms
[function] fragment-complexity=low:fragment-steps=5: FPS: 1412 FrameTime: 0.708 ms
[function] fragment-complexity=medium:fragment-steps=5: FPS: 1416 FrameTime: 0.706 ms
[loop] fragment-loop=false:fragment-steps=5:vertex-steps=5: FPS: 1369 FrameTime: 0.730 ms
[loop] fragment-steps=5:fragment-uniform=false:vertex-steps=5: FPS: 1388 FrameTime: 0.720 ms
[loop] fragment-steps=5:fragment-uniform=true:vertex-steps=5: FPS: 1383 FrameTime: 0.723 ms
}}

=== Discrete graphics card ===
==== NVIDIA RTX2060 6GB + AMD Ryzen 7 3700X 8-Core 4GHz ====
Note that some tests resulted in errors and finally a core dump, so there is no final glmark2 Score.

{{collapsible script
| type = details
| title = (click show to expand)
| lang = text
| script =----
glmark2 2021.02
----
OpenGL Information
GL_VENDOR: NVIDIA Corporation
GL_RENDERER: NVIDIA GeForce RTX 2060/PCIe/SSE2
GL_VERSION: 4.6.0 NVIDIA 495.46
----
<pre>
[build] use-vbo=false: FPS: 13809 FrameTime: 0.072 ms
[build] use-vbo=true: FPS: 28367 FrameTime: 0.035 ms
[texture] texture-filter=nearest: FPS: 27958 FrameTime: 0.036 ms
[texture] texture-filter=linear: FPS: 28120 FrameTime: 0.036 ms
[texture] texture-filter=mipmap: FPS: 28036 FrameTime: 0.036 ms
[shading] shading=gouraud: FPS: 26428 FrameTime: 0.038 ms
[shading] shading=blinn-phong-inf: FPS: 26320 FrameTime: 0.038 ms
[shading] shading=phong: FPS: 25800 FrameTime: 0.039 ms
[shading] shading=cel: FPS: 25498 FrameTime: 0.039 ms
[bump] bump-render=high-poly: FPS: 20696 FrameTime: 0.048 ms
[bump] bump-render=normals: FPS: 29599 FrameTime: 0.034 ms
Error: Failed to add fragment shader from file None:
Error: 0(15) : error C0000: syntax error, unexpected identifier, expecting "::" at token "highp"
Error: 0(36) : warning C1503: undefined variable "TextureCoord"
Error: 0(37) : warning C1503: undefined variable "TextureCoord"
Error: 0(38) : warning C1503: undefined variable "TextureCoord"
Error:
[bump] bump-render=height: Set up failed
[effect2d] kernel=0,1,0;1,-4,1;0,1,0;: FPS: 22140 FrameTime: 0.045 ms
[effect2d] kernel=1,1,1,1,1;1,1,1,1,1;1,1,1,1,1;: FPS: 15018 FrameTime: 0.067 ms
[pulsar] light=false:quads=5:texture=false: FPS: 27482 FrameTime: 0.036 ms
[desktop] blur-radius=5:effect=blur:passes=1:separable=true:windows=4: FPS: 8226 FrameTime: 0.122 ms
[desktop] effect=shadow:windows=4: FPS: 10260 FrameTime: 0.097 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 1490 FrameTime: 0.671 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=subdata: FPS: 1613 FrameTime: 0.620 ms
[buffer] columns=200:interleave=true:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 2147 FrameTime: 0.466 ms
[ideas] speed=duration: FPS: 14164 FrameTime: 0.071 ms
[jellyfish] <default>: FPS: 20591 FrameTime: 0.049 ms
Error: Failed to add fragment shader from file None:
Error: 0(26) : warning C7022: unrecognized profile specifier "highp"
Error: 0(26) : error C0502: syntax error at token "highp"
Error:
Error: Failed to add fragment shader from file None:
Error: 0(75) : warning C7022: unrecognized profile specifier "highp"
Error: 0(75) : error C0502: syntax error at token "highp"
Error:
[terrain] <default>:Segmentation fault (core dumped)</pre>
----
}}

==== AMD Tahiti XT [Radeon HD 7970 / R9 280X] + Intel Core i5-11600K @ 3.90GHz ====

'''glmark2 Score: 13781'''

{{collapsible script
| type = details
| title = (click show to expand)
| lang = text
| script = ----
glmark2 2021.02
----
OpenGL Information
GL_VENDOR: AMD
GL_RENDERER: AMD TAHITI (DRM 2.50.0, 5.11.0-44-generic, LLVM 12.0.0)
GL_VERSION: 4.5 (Compatibility Profile) Mesa 21.0.3
----
[build] use-vbo=false: FPS: 12290 FrameTime: 0.081 ms
[build] use-vbo=true: FPS: 19086 FrameTime: 0.052 ms
[texture] texture-filter=nearest: FPS: 18131 FrameTime: 0.055 ms
[texture] texture-filter=linear: FPS: 18165 FrameTime: 0.055 ms
[texture] texture-filter=mipmap: FPS: 18563 FrameTime: 0.054 ms
[shading] shading=gouraud: FPS: 16185 FrameTime: 0.062 ms
[shading] shading=blinn-phong-inf: FPS: 16135 FrameTime: 0.062 ms
[shading] shading=phong: FPS: 16042 FrameTime: 0.062 ms
[shading] shading=cel: FPS: 16036 FrameTime: 0.062 ms
[bump] bump-render=high-poly: FPS: 9338 FrameTime: 0.107 ms
[bump] bump-render=normals: FPS: 19774 FrameTime: 0.051 ms
[bump] bump-render=height: FPS: 19534 FrameTime: 0.051 ms
[effect2d] kernel=0,1,0;1,-4,1;0,1,0;: FPS: 15477 FrameTime: 0.065 ms
[effect2d] kernel=1,1,1,1,1;1,1,1,1,1;1,1,1,1,1;: FPS: 10139 FrameTime: 0.099 ms
[pulsar] light=false:quads=5:texture=false: FPS: 16858 FrameTime: 0.059 ms
[desktop] blur-radius=5:effect=blur:passes=1:separable=true:windows=4: FPS: 5961 FrameTime: 0.168 ms
[desktop] effect=shadow:windows=4: FPS: 9994 FrameTime: 0.100 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 2577 FrameTime: 0.388 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=subdata: FPS: 3585 FrameTime: 0.279 ms
[buffer] columns=200:interleave=true:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 3158 FrameTime: 0.317 ms
[ideas] speed=duration: FPS: 11924 FrameTime: 0.084 ms
[jellyfish] <default>: FPS: 12073 FrameTime: 0.083 ms
[terrain] <default>: FPS: 1350 FrameTime: 0.741 ms
[shadow] <default>: FPS: 9986 FrameTime: 0.100 ms
[refract] <default>: FPS: 2500 FrameTime: 0.400 ms
[conditionals] fragment-steps=0:vertex-steps=0: FPS: 18815 FrameTime: 0.053 ms
[conditionals] fragment-steps=5:vertex-steps=0: FPS: 18705 FrameTime: 0.053 ms
[conditionals] fragment-steps=0:vertex-steps=5: FPS: 18787 FrameTime: 0.053 ms
[function] fragment-complexity=low:fragment-steps=5: FPS: 18759 FrameTime: 0.053 ms
[function] fragment-complexity=medium:fragment-steps=5: FPS: 18691 FrameTime: 0.054 ms
[loop] fragment-loop=false:fragment-steps=5:vertex-steps=5: FPS: 18755 FrameTime: 0.053 ms
[loop] fragment-steps=5:fragment-uniform=false:vertex-steps=5: FPS: 18759 FrameTime: 0.053 ms
[loop] fragment-steps=5:fragment-uniform=true:vertex-steps=5: FPS: 18654 FrameTime: 0.054 ms
}}

==== NVIDIA GTX-1060 6GB + AMD R7 3700X @ 4.2 GHz, 8 cores, HT off ====

'''glmark2 Score: 20641'''

{{collapsible script
| type = details
| title = (click show to expand)
| lang = text
| script = ----
glmark2 2014.03+git20150611.fa71af2d
----
OpenGL Information
GL_VENDOR: NVIDIA Corporation
GL_RENDERER: GeForce GTX 1060 6GB/PCIe/SSE2
GL_VERSION: 4.6.0 NVIDIA 460.91.03
----
[build] use-vbo=false: FPS: 15192 FrameTime: 0.066 ms
[build] use-vbo=true: FPS: 30325 FrameTime: 0.033 ms
[texture] texture-filter=nearest: FPS: 27634 FrameTime: 0.036 ms
[texture] texture-filter=linear: FPS: 27511 FrameTime: 0.036 ms
[texture] texture-filter=mipmap: FPS: 28397 FrameTime: 0.035 ms
[shading] shading=gouraud: FPS: 26079 FrameTime: 0.038 ms
[shading] shading=blinn-phong-inf: FPS: 25796 FrameTime: 0.039 ms
[shading] shading=phong: FPS: 25060 FrameTime: 0.040 ms
[shading] shading=cel: FPS: 25321 FrameTime: 0.039 ms
[bump] bump-render=high-poly: FPS: 17451 FrameTime: 0.057 ms
[bump] bump-render=normals: FPS: 31963 FrameTime: 0.031 ms
[bump] bump-render=height: FPS: 31608 FrameTime: 0.032 ms
[effect2d] kernel=0,1,0;1,-4,1;0,1,0;: FPS: 20418 FrameTime: 0.049 ms
[effect2d] kernel=1,1,1,1,1;1,1,1,1,1;1,1,1,1,1;: FPS: 12585 FrameTime: 0.079 ms
[pulsar] light=false:quads=5:texture=false: FPS: 28174 FrameTime: 0.035 ms
[desktop] blur-radius=5:effect=blur:passes=1:separable=true:windows=4: FPS: 7331 FrameTime: 0.136 ms
[desktop] effect=shadow:windows=4: FPS: 14034 FrameTime: 0.071 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 2363 FrameTime: 0.423 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=subdata: FPS: 2783 FrameTime: 0.359 ms
[buffer] columns=200:interleave=true:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 2330 FrameTime: 0.429 ms
[ideas] speed=duration: FPS: 19421 FrameTime: 0.051 ms
[jellyfish] <default>: FPS: 17291 FrameTime: 0.058 ms
[terrain] <default>: FPS: 1349 FrameTime: 0.741 ms
[shadow] <default>: FPS: 15688 FrameTime: 0.064 ms
[refract] <default>: FPS: 4783 FrameTime: 0.209 ms
[conditionals] fragment-steps=0:vertex-steps=0: FPS: 28599 FrameTime: 0.035 ms
[conditionals] fragment-steps=5:vertex-steps=0: FPS: 27499 FrameTime: 0.036 ms
[conditionals] fragment-steps=0:vertex-steps=5: FPS: 28191 FrameTime: 0.035 ms
[function] fragment-complexity=low:fragment-steps=5: FPS: 27695 FrameTime: 0.036 ms
[function] fragment-complexity=medium:fragment-steps=5: FPS: 26605 FrameTime: 0.038 ms
[loop] fragment-loop=false:fragment-steps=5:vertex-steps=5: FPS: 27340 FrameTime: 0.037 ms
[loop] fragment-steps=5:fragment-uniform=false:vertex-steps=5: FPS: 27361 FrameTime: 0.037 ms
[loop] fragment-steps=5:fragment-uniform=true:vertex-steps=5: FPS: 26984 FrameTime: 0.037 ms
}}

==== NVIDIA Quadro K1000M 1GB + Intel Core i7-3610Q @ 2.3 GHz ====
Remark: during glmark2 testing CPU clock boosted to 3.3 GHz

''' glmark2 Score: 2754 '''

{{collapsible script
| type = details
| title = (click show to expand)
| lang = text
| script = ----
glmark2 2014.03+git20150611.fa71af2d
----
OpenGL Information
GL_VENDOR: NVIDIA Corporation
GL_RENDERER: Quadro K1000M/PCIe/SSE2
GL_VERSION: 4.6.0 NVIDIA 390.138
----
[build] use-vbo=false: FPS: 4154 FrameTime: 0.241 ms
[build] use-vbo=true: FPS: 4205 FrameTime: 0.238 ms
[texture] texture-filter=nearest: FPS: 3791 FrameTime: 0.264 ms
[texture] texture-filter=linear: FPS: 3718 FrameTime: 0.269 ms
[texture] texture-filter=mipmap: FPS: 3761 FrameTime: 0.266 ms
[shading] shading=gouraud: FPS: 3187 FrameTime: 0.314 ms
[shading] shading=blinn-phong-inf: FPS: 3200 FrameTime: 0.312 ms
[shading] shading=phong: FPS: 3078 FrameTime: 0.325 ms
[shading] shading=cel: FPS: 3065 FrameTime: 0.326 ms
[bump] bump-render=high-poly: FPS: 1674 FrameTime: 0.597 ms
[bump] bump-render=normals: FPS: 4329 FrameTime: 0.231 ms
[bump] bump-render=height: FPS: 4174 FrameTime: 0.240 ms
[effect2d] kernel=0,1,0;1,-4,1;0,1,0;: FPS: 2356 FrameTime: 0.424 ms
[effect2d] kernel=1,1,1,1,1;1,1,1,1,1;1,1,1,1,1;: FPS: 1249 FrameTime: 0.801 ms
[pulsar] light=false:quads=5:texture=false: FPS: 3550 FrameTime: 0.282 ms
[desktop] blur-radius=5:effect=blur:passes=1:separable=true:windows=4: FPS: 888 FrameTime: 1.126 ms
[desktop] effect=shadow:windows=4: FPS: 1453 FrameTime: 0.688 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 952 FrameTime: 1.050 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=subdata: FPS: 1277 FrameTime: 0.783 ms
[buffer] columns=200:interleave=true:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 977 FrameTime: 1.024 ms
[ideas] speed=duration: FPS: 2926 FrameTime: 0.342 ms
[jellyfish] <default>: FPS: 1551 FrameTime: 0.645 ms
[terrain] <default>: FPS: 173 FrameTime: 5.780 ms
[shadow] <default>: FPS: 2420 FrameTime: 0.413 ms
[refract] <default>: FPS: 431 FrameTime: 2.320 ms
[conditionals] fragment-steps=0:vertex-steps=0: FPS: 3776 FrameTime: 0.265 ms
[conditionals] fragment-steps=5:vertex-steps=0: FPS: 3061 FrameTime: 0.327 ms
[conditionals] fragment-steps=0:vertex-steps=5: FPS: 3776 FrameTime: 0.265 ms
[function] fragment-complexity=low:fragment-steps=5: FPS: 3775 FrameTime: 0.265 ms
[function] fragment-complexity=medium:fragment-steps=5: FPS: 3058 FrameTime: 0.327 ms
[loop] fragment-loop=false:fragment-steps=5:vertex-steps=5: FPS: 3776 FrameTime: 0.265 ms
[loop] fragment-steps=5:fragment-uniform=false:vertex-steps=5: FPS: 3776 FrameTime: 0.265 ms
[loop] fragment-steps=5:fragment-uniform=true:vertex-steps=5: FPS: 3375 FrameTime: 0.296 ms
}}

OpenGL performance

2022-01-09T12:40:30Z

MariuszXC: NVIDIA Quadro K1000M + Intel Core i7-3610Q

== OpenGL performance ==
OpenGL performance can be tested using glmark2 program. It is available in most Linux distributions. In Debian derived distributions (like Ubuntu) it can be installed by issuing ''sudo apt install glmark2'' from command line.

The data presented below was taken by running ''glmark2'' without any additional options, i.e. with default settings, on an otherwise idle system.

By comparing your results with measurements taken on other similar systems you can verify if your hardware and software combination is performing as expected.

=== Intel i5-4310M @ 2.70 GHz ===
This is a 4th gen. Intel Core i5 mobile (laptop) CPU with built-in graphics.

'''glmark2 Score: 1668'''

{{collapsible script
| type = details
| title = (click show to expand)
| lang = text
| script = ----
glmark2 2014.03+git20150611.fa71af2d
----
OpenGL Information
GL_VENDOR: Intel Open Source Technology Center
GL_RENDERER: Mesa DRI Intel(R) Haswell Mobile
GL_VERSION: 3.0 Mesa 18.0.5
----
<pre>
[build] use-vbo=false: FPS: 2256 FrameTime: 0.443 ms
[build] use-vbo=true: FPS: 2500 FrameTime: 0.400 ms
[texture] texture-filter=nearest: FPS: 2183 FrameTime: 0.458 ms
[texture] texture-filter=linear: FPS: 2180 FrameTime: 0.459 ms
[texture] texture-filter=mipmap: FPS: 2250 FrameTime: 0.444 ms
[shading] shading=gouraud: FPS: 2042 FrameTime: 0.490 ms
[shading] shading=blinn-phong-inf: FPS: 2049 FrameTime: 0.488 ms
[shading] shading=phong: FPS: 1938 FrameTime: 0.516 ms
[shading] shading=cel: FPS: 2037 FrameTime: 0.491 ms
[bump] bump-render=high-poly: FPS: 1701 FrameTime: 0.588 ms
[bump] bump-render=normals: FPS: 2419 FrameTime: 0.413 ms
[bump] bump-render=height: FPS: 2382 FrameTime: 0.420 ms
[effect2d] kernel=0,1,0;1,-4,1;0,1,0;: FPS: 1758 FrameTime: 0.569 ms
[effect2d] kernel=1,1,1,1,1;1,1,1,1,1;1,1,1,1,1;: FPS: 886 FrameTime: 1.129 ms
[pulsar] light=false:quads=5:texture=false: FPS: 2008 FrameTime: 0.498 ms
[desktop] blur-radius=5:effect=blur:passes=1:separable=true:windows=4: FPS: 749 FrameTime: 1.335 ms
[desktop] effect=shadow:windows=4: FPS: 1094 FrameTime: 0.914 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 770 FrameTime: 1.299 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=subdata: FPS: 655 FrameTime: 1.527 ms
[buffer] columns=200:interleave=true:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 857 FrameTime: 1.167 ms
[ideas] speed=duration: FPS: 1776 FrameTime: 0.563 ms
[jellyfish] <default>: FPS: 1275 FrameTime: 0.784 ms
[terrain] <default>: FPS: 173 FrameTime: 5.780 ms
[shadow] <default>: FPS: 805 FrameTime: 1.242 ms
[refract] <default>: FPS: 268 FrameTime: 3.731 ms
[conditionals] fragment-steps=0:vertex-steps=0: FPS: 2038 FrameTime: 0.491 ms
[conditionals] fragment-steps=5:vertex-steps=0: FPS: 2039 FrameTime: 0.490 ms
[conditionals] fragment-steps=0:vertex-steps=5: FPS: 2028 FrameTime: 0.493 ms
[function] fragment-complexity=low:fragment-steps=5: FPS: 2037 FrameTime: 0.491 ms
[function] fragment-complexity=medium:fragment-steps=5: FPS: 2051 FrameTime: 0.488 ms
[loop] fragment-loop=false:fragment-steps=5:vertex-steps=5: FPS: 1879 FrameTime: 0.532 ms
[loop] fragment-steps=5:fragment-uniform=false:vertex-steps=5: FPS: 1922 FrameTime: 0.520 ms
[loop] fragment-steps=5:fragment-uniform=true:vertex-steps=5: FPS: 2039 FrameTime: 0.490 ms</pre>
}}

=== NVIDIA RTX2060 6GB + AMD Ryzen 7 3700X 8-Core 4GHz ===
Note that some tests resulted in errors and finally a core dump, so there is no final glmark2 Score.

{{collapsible script
| type = details
| title = (click show to expand)
| lang = text
| script =----
glmark2 2021.02
----
OpenGL Information
GL_VENDOR: NVIDIA Corporation
GL_RENDERER: NVIDIA GeForce RTX 2060/PCIe/SSE2
GL_VERSION: 4.6.0 NVIDIA 495.46
----
<pre>
[build] use-vbo=false: FPS: 13809 FrameTime: 0.072 ms
[build] use-vbo=true: FPS: 28367 FrameTime: 0.035 ms
[texture] texture-filter=nearest: FPS: 27958 FrameTime: 0.036 ms
[texture] texture-filter=linear: FPS: 28120 FrameTime: 0.036 ms
[texture] texture-filter=mipmap: FPS: 28036 FrameTime: 0.036 ms
[shading] shading=gouraud: FPS: 26428 FrameTime: 0.038 ms
[shading] shading=blinn-phong-inf: FPS: 26320 FrameTime: 0.038 ms
[shading] shading=phong: FPS: 25800 FrameTime: 0.039 ms
[shading] shading=cel: FPS: 25498 FrameTime: 0.039 ms
[bump] bump-render=high-poly: FPS: 20696 FrameTime: 0.048 ms
[bump] bump-render=normals: FPS: 29599 FrameTime: 0.034 ms
Error: Failed to add fragment shader from file None:
Error: 0(15) : error C0000: syntax error, unexpected identifier, expecting "::" at token "highp"
Error: 0(36) : warning C1503: undefined variable "TextureCoord"
Error: 0(37) : warning C1503: undefined variable "TextureCoord"
Error: 0(38) : warning C1503: undefined variable "TextureCoord"
Error:
[bump] bump-render=height: Set up failed
[effect2d] kernel=0,1,0;1,-4,1;0,1,0;: FPS: 22140 FrameTime: 0.045 ms
[effect2d] kernel=1,1,1,1,1;1,1,1,1,1;1,1,1,1,1;: FPS: 15018 FrameTime: 0.067 ms
[pulsar] light=false:quads=5:texture=false: FPS: 27482 FrameTime: 0.036 ms
[desktop] blur-radius=5:effect=blur:passes=1:separable=true:windows=4: FPS: 8226 FrameTime: 0.122 ms
[desktop] effect=shadow:windows=4: FPS: 10260 FrameTime: 0.097 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 1490 FrameTime: 0.671 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=subdata: FPS: 1613 FrameTime: 0.620 ms
[buffer] columns=200:interleave=true:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 2147 FrameTime: 0.466 ms
[ideas] speed=duration: FPS: 14164 FrameTime: 0.071 ms
[jellyfish] <default>: FPS: 20591 FrameTime: 0.049 ms
Error: Failed to add fragment shader from file None:
Error: 0(26) : warning C7022: unrecognized profile specifier "highp"
Error: 0(26) : error C0502: syntax error at token "highp"
Error:
Error: Failed to add fragment shader from file None:
Error: 0(75) : warning C7022: unrecognized profile specifier "highp"
Error: 0(75) : error C0502: syntax error at token "highp"
Error:
[terrain] <default>:Segmentation fault (core dumped)</pre>
----
}}

=== AMD Tahiti XT [Radeon HD 7970 / R9 280X] + Intel Core i5-11600K @ 3.90GHz ===

'''glmark2 Score: 13781'''

{{collapsible script
| type = details
| title = (click show to expand)
| lang = text
| script = ----
glmark2 2021.02
----
OpenGL Information
GL_VENDOR: AMD
GL_RENDERER: AMD TAHITI (DRM 2.50.0, 5.11.0-44-generic, LLVM 12.0.0)
GL_VERSION: 4.5 (Compatibility Profile) Mesa 21.0.3
----
[build] use-vbo=false: FPS: 12290 FrameTime: 0.081 ms
[build] use-vbo=true: FPS: 19086 FrameTime: 0.052 ms
[texture] texture-filter=nearest: FPS: 18131 FrameTime: 0.055 ms
[texture] texture-filter=linear: FPS: 18165 FrameTime: 0.055 ms
[texture] texture-filter=mipmap: FPS: 18563 FrameTime: 0.054 ms
[shading] shading=gouraud: FPS: 16185 FrameTime: 0.062 ms
[shading] shading=blinn-phong-inf: FPS: 16135 FrameTime: 0.062 ms
[shading] shading=phong: FPS: 16042 FrameTime: 0.062 ms
[shading] shading=cel: FPS: 16036 FrameTime: 0.062 ms
[bump] bump-render=high-poly: FPS: 9338 FrameTime: 0.107 ms
[bump] bump-render=normals: FPS: 19774 FrameTime: 0.051 ms
[bump] bump-render=height: FPS: 19534 FrameTime: 0.051 ms
[effect2d] kernel=0,1,0;1,-4,1;0,1,0;: FPS: 15477 FrameTime: 0.065 ms
[effect2d] kernel=1,1,1,1,1;1,1,1,1,1;1,1,1,1,1;: FPS: 10139 FrameTime: 0.099 ms
[pulsar] light=false:quads=5:texture=false: FPS: 16858 FrameTime: 0.059 ms
[desktop] blur-radius=5:effect=blur:passes=1:separable=true:windows=4: FPS: 5961 FrameTime: 0.168 ms
[desktop] effect=shadow:windows=4: FPS: 9994 FrameTime: 0.100 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 2577 FrameTime: 0.388 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=subdata: FPS: 3585 FrameTime: 0.279 ms
[buffer] columns=200:interleave=true:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 3158 FrameTime: 0.317 ms
[ideas] speed=duration: FPS: 11924 FrameTime: 0.084 ms
[jellyfish] <default>: FPS: 12073 FrameTime: 0.083 ms
[terrain] <default>: FPS: 1350 FrameTime: 0.741 ms
[shadow] <default>: FPS: 9986 FrameTime: 0.100 ms
[refract] <default>: FPS: 2500 FrameTime: 0.400 ms
[conditionals] fragment-steps=0:vertex-steps=0: FPS: 18815 FrameTime: 0.053 ms
[conditionals] fragment-steps=5:vertex-steps=0: FPS: 18705 FrameTime: 0.053 ms
[conditionals] fragment-steps=0:vertex-steps=5: FPS: 18787 FrameTime: 0.053 ms
[function] fragment-complexity=low:fragment-steps=5: FPS: 18759 FrameTime: 0.053 ms
[function] fragment-complexity=medium:fragment-steps=5: FPS: 18691 FrameTime: 0.054 ms
[loop] fragment-loop=false:fragment-steps=5:vertex-steps=5: FPS: 18755 FrameTime: 0.053 ms
[loop] fragment-steps=5:fragment-uniform=false:vertex-steps=5: FPS: 18759 FrameTime: 0.053 ms
[loop] fragment-steps=5:fragment-uniform=true:vertex-steps=5: FPS: 18654 FrameTime: 0.054 ms
}}

=== NVIDIA GTX-1060 6GB + AMD R7 3700X @4.2 GHz, 8 cores, HT off ===

'''glmark2 Score: 20641'''

{{collapsible script
| type = details
| title = (click show to expand)
| lang = text
| script = ----
glmark2 2014.03+git20150611.fa71af2d
----
OpenGL Information
GL_VENDOR: NVIDIA Corporation
GL_RENDERER: GeForce GTX 1060 6GB/PCIe/SSE2
GL_VERSION: 4.6.0 NVIDIA 460.91.03
----
[build] use-vbo=false: FPS: 15192 FrameTime: 0.066 ms
[build] use-vbo=true: FPS: 30325 FrameTime: 0.033 ms
[texture] texture-filter=nearest: FPS: 27634 FrameTime: 0.036 ms
[texture] texture-filter=linear: FPS: 27511 FrameTime: 0.036 ms
[texture] texture-filter=mipmap: FPS: 28397 FrameTime: 0.035 ms
[shading] shading=gouraud: FPS: 26079 FrameTime: 0.038 ms
[shading] shading=blinn-phong-inf: FPS: 25796 FrameTime: 0.039 ms
[shading] shading=phong: FPS: 25060 FrameTime: 0.040 ms
[shading] shading=cel: FPS: 25321 FrameTime: 0.039 ms
[bump] bump-render=high-poly: FPS: 17451 FrameTime: 0.057 ms
[bump] bump-render=normals: FPS: 31963 FrameTime: 0.031 ms
[bump] bump-render=height: FPS: 31608 FrameTime: 0.032 ms
[effect2d] kernel=0,1,0;1,-4,1;0,1,0;: FPS: 20418 FrameTime: 0.049 ms
[effect2d] kernel=1,1,1,1,1;1,1,1,1,1;1,1,1,1,1;: FPS: 12585 FrameTime: 0.079 ms
[pulsar] light=false:quads=5:texture=false: FPS: 28174 FrameTime: 0.035 ms
[desktop] blur-radius=5:effect=blur:passes=1:separable=true:windows=4: FPS: 7331 FrameTime: 0.136 ms
[desktop] effect=shadow:windows=4: FPS: 14034 FrameTime: 0.071 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 2363 FrameTime: 0.423 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=subdata: FPS: 2783 FrameTime: 0.359 ms
[buffer] columns=200:interleave=true:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 2330 FrameTime: 0.429 ms
[ideas] speed=duration: FPS: 19421 FrameTime: 0.051 ms
[jellyfish] <default>: FPS: 17291 FrameTime: 0.058 ms
[terrain] <default>: FPS: 1349 FrameTime: 0.741 ms
[shadow] <default>: FPS: 15688 FrameTime: 0.064 ms
[refract] <default>: FPS: 4783 FrameTime: 0.209 ms
[conditionals] fragment-steps=0:vertex-steps=0: FPS: 28599 FrameTime: 0.035 ms
[conditionals] fragment-steps=5:vertex-steps=0: FPS: 27499 FrameTime: 0.036 ms
[conditionals] fragment-steps=0:vertex-steps=5: FPS: 28191 FrameTime: 0.035 ms
[function] fragment-complexity=low:fragment-steps=5: FPS: 27695 FrameTime: 0.036 ms
[function] fragment-complexity=medium:fragment-steps=5: FPS: 26605 FrameTime: 0.038 ms
[loop] fragment-loop=false:fragment-steps=5:vertex-steps=5: FPS: 27340 FrameTime: 0.037 ms
[loop] fragment-steps=5:fragment-uniform=false:vertex-steps=5: FPS: 27361 FrameTime: 0.037 ms
[loop] fragment-steps=5:fragment-uniform=true:vertex-steps=5: FPS: 26984 FrameTime: 0.037 ms
}}

=== NVIDIA Quadro K1000M 1GB + Intel Core i7-3610Q @2.3 GHz ===
Remark: during glmark2 testing CPU clock boosted to 3.3 GHz

''' glmark2 Score: 2754 '''

{{collapsible script
| type = details
| title = (click show to expand)
| lang = text
| script = ----
glmark2 2014.03+git20150611.fa71af2d
----
OpenGL Information
GL_VENDOR: NVIDIA Corporation
GL_RENDERER: Quadro K1000M/PCIe/SSE2
GL_VERSION: 4.6.0 NVIDIA 390.138
----
[build] use-vbo=false: FPS: 4154 FrameTime: 0.241 ms
[build] use-vbo=true: FPS: 4205 FrameTime: 0.238 ms
[texture] texture-filter=nearest: FPS: 3791 FrameTime: 0.264 ms
[texture] texture-filter=linear: FPS: 3718 FrameTime: 0.269 ms
[texture] texture-filter=mipmap: FPS: 3761 FrameTime: 0.266 ms
[shading] shading=gouraud: FPS: 3187 FrameTime: 0.314 ms
[shading] shading=blinn-phong-inf: FPS: 3200 FrameTime: 0.312 ms
[shading] shading=phong: FPS: 3078 FrameTime: 0.325 ms
[shading] shading=cel: FPS: 3065 FrameTime: 0.326 ms
[bump] bump-render=high-poly: FPS: 1674 FrameTime: 0.597 ms
[bump] bump-render=normals: FPS: 4329 FrameTime: 0.231 ms
[bump] bump-render=height: FPS: 4174 FrameTime: 0.240 ms
[effect2d] kernel=0,1,0;1,-4,1;0,1,0;: FPS: 2356 FrameTime: 0.424 ms
[effect2d] kernel=1,1,1,1,1;1,1,1,1,1;1,1,1,1,1;: FPS: 1249 FrameTime: 0.801 ms
[pulsar] light=false:quads=5:texture=false: FPS: 3550 FrameTime: 0.282 ms
[desktop] blur-radius=5:effect=blur:passes=1:separable=true:windows=4: FPS: 888 FrameTime: 1.126 ms
[desktop] effect=shadow:windows=4: FPS: 1453 FrameTime: 0.688 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 952 FrameTime: 1.050 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=subdata: FPS: 1277 FrameTime: 0.783 ms
[buffer] columns=200:interleave=true:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 977 FrameTime: 1.024 ms
[ideas] speed=duration: FPS: 2926 FrameTime: 0.342 ms
[jellyfish] <default>: FPS: 1551 FrameTime: 0.645 ms
[terrain] <default>: FPS: 173 FrameTime: 5.780 ms
[shadow] <default>: FPS: 2420 FrameTime: 0.413 ms
[refract] <default>: FPS: 431 FrameTime: 2.320 ms
[conditionals] fragment-steps=0:vertex-steps=0: FPS: 3776 FrameTime: 0.265 ms
[conditionals] fragment-steps=5:vertex-steps=0: FPS: 3061 FrameTime: 0.327 ms
[conditionals] fragment-steps=0:vertex-steps=5: FPS: 3776 FrameTime: 0.265 ms
[function] fragment-complexity=low:fragment-steps=5: FPS: 3775 FrameTime: 0.265 ms
[function] fragment-complexity=medium:fragment-steps=5: FPS: 3058 FrameTime: 0.327 ms
[loop] fragment-loop=false:fragment-steps=5:vertex-steps=5: FPS: 3776 FrameTime: 0.265 ms
[loop] fragment-steps=5:fragment-uniform=false:vertex-steps=5: FPS: 3776 FrameTime: 0.265 ms
[loop] fragment-steps=5:fragment-uniform=true:vertex-steps=5: FPS: 3375 FrameTime: 0.296 ms
}}

OpenGL performance

2022-01-09T12:39:06Z

MariuszXC:

== OpenGL performance ==
OpenGL performance can be tested using glmark2 program. It is available in most Linux distributions. In Debian derived distributions (like Ubuntu) it can be installed by issuing ''sudo apt install glmark2'' from command line.

The data presented below was taken by running ''glmark2'' without any additional options, i.e. with default settings, on an otherwise idle system.

By comparing your results with measurements taken on other similar systems you can verify if your hardware and software combination is performing as expected.

=== Intel i5-4310M @ 2.70 GHz ===
This is a 4th gen. Intel Core i5 mobile (laptop) CPU with built-in graphics.

'''glmark2 Score: 1668'''

{{collapsible script
| type = details
| title = (click show to expand)
| lang = text
| script = ----
glmark2 2014.03+git20150611.fa71af2d
----
OpenGL Information
GL_VENDOR: Intel Open Source Technology Center
GL_RENDERER: Mesa DRI Intel(R) Haswell Mobile
GL_VERSION: 3.0 Mesa 18.0.5
----
<pre>
[build] use-vbo=false: FPS: 2256 FrameTime: 0.443 ms
[build] use-vbo=true: FPS: 2500 FrameTime: 0.400 ms
[texture] texture-filter=nearest: FPS: 2183 FrameTime: 0.458 ms
[texture] texture-filter=linear: FPS: 2180 FrameTime: 0.459 ms
[texture] texture-filter=mipmap: FPS: 2250 FrameTime: 0.444 ms
[shading] shading=gouraud: FPS: 2042 FrameTime: 0.490 ms
[shading] shading=blinn-phong-inf: FPS: 2049 FrameTime: 0.488 ms
[shading] shading=phong: FPS: 1938 FrameTime: 0.516 ms
[shading] shading=cel: FPS: 2037 FrameTime: 0.491 ms
[bump] bump-render=high-poly: FPS: 1701 FrameTime: 0.588 ms
[bump] bump-render=normals: FPS: 2419 FrameTime: 0.413 ms
[bump] bump-render=height: FPS: 2382 FrameTime: 0.420 ms
[effect2d] kernel=0,1,0;1,-4,1;0,1,0;: FPS: 1758 FrameTime: 0.569 ms
[effect2d] kernel=1,1,1,1,1;1,1,1,1,1;1,1,1,1,1;: FPS: 886 FrameTime: 1.129 ms
[pulsar] light=false:quads=5:texture=false: FPS: 2008 FrameTime: 0.498 ms
[desktop] blur-radius=5:effect=blur:passes=1:separable=true:windows=4: FPS: 749 FrameTime: 1.335 ms
[desktop] effect=shadow:windows=4: FPS: 1094 FrameTime: 0.914 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 770 FrameTime: 1.299 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=subdata: FPS: 655 FrameTime: 1.527 ms
[buffer] columns=200:interleave=true:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 857 FrameTime: 1.167 ms
[ideas] speed=duration: FPS: 1776 FrameTime: 0.563 ms
[jellyfish] <default>: FPS: 1275 FrameTime: 0.784 ms
[terrain] <default>: FPS: 173 FrameTime: 5.780 ms
[shadow] <default>: FPS: 805 FrameTime: 1.242 ms
[refract] <default>: FPS: 268 FrameTime: 3.731 ms
[conditionals] fragment-steps=0:vertex-steps=0: FPS: 2038 FrameTime: 0.491 ms
[conditionals] fragment-steps=5:vertex-steps=0: FPS: 2039 FrameTime: 0.490 ms
[conditionals] fragment-steps=0:vertex-steps=5: FPS: 2028 FrameTime: 0.493 ms
[function] fragment-complexity=low:fragment-steps=5: FPS: 2037 FrameTime: 0.491 ms
[function] fragment-complexity=medium:fragment-steps=5: FPS: 2051 FrameTime: 0.488 ms
[loop] fragment-loop=false:fragment-steps=5:vertex-steps=5: FPS: 1879 FrameTime: 0.532 ms
[loop] fragment-steps=5:fragment-uniform=false:vertex-steps=5: FPS: 1922 FrameTime: 0.520 ms
[loop] fragment-steps=5:fragment-uniform=true:vertex-steps=5: FPS: 2039 FrameTime: 0.490 ms</pre>
}}

=== NVIDIA RTX2060 6GB + AMD Ryzen 7 3700X 8-Core 4GHz ===
Note that some tests resulted in errors and finally a core dump, so there is no final glmark2 Score.

{{collapsible script
| type = details
| title = (click show to expand)
| lang = text
| script =----
glmark2 2021.02
----
OpenGL Information
GL_VENDOR: NVIDIA Corporation
GL_RENDERER: NVIDIA GeForce RTX 2060/PCIe/SSE2
GL_VERSION: 4.6.0 NVIDIA 495.46
----
<pre>
[build] use-vbo=false: FPS: 13809 FrameTime: 0.072 ms
[build] use-vbo=true: FPS: 28367 FrameTime: 0.035 ms
[texture] texture-filter=nearest: FPS: 27958 FrameTime: 0.036 ms
[texture] texture-filter=linear: FPS: 28120 FrameTime: 0.036 ms
[texture] texture-filter=mipmap: FPS: 28036 FrameTime: 0.036 ms
[shading] shading=gouraud: FPS: 26428 FrameTime: 0.038 ms
[shading] shading=blinn-phong-inf: FPS: 26320 FrameTime: 0.038 ms
[shading] shading=phong: FPS: 25800 FrameTime: 0.039 ms
[shading] shading=cel: FPS: 25498 FrameTime: 0.039 ms
[bump] bump-render=high-poly: FPS: 20696 FrameTime: 0.048 ms
[bump] bump-render=normals: FPS: 29599 FrameTime: 0.034 ms
Error: Failed to add fragment shader from file None:
Error: 0(15) : error C0000: syntax error, unexpected identifier, expecting "::" at token "highp"
Error: 0(36) : warning C1503: undefined variable "TextureCoord"
Error: 0(37) : warning C1503: undefined variable "TextureCoord"
Error: 0(38) : warning C1503: undefined variable "TextureCoord"
Error:
[bump] bump-render=height: Set up failed
[effect2d] kernel=0,1,0;1,-4,1;0,1,0;: FPS: 22140 FrameTime: 0.045 ms
[effect2d] kernel=1,1,1,1,1;1,1,1,1,1;1,1,1,1,1;: FPS: 15018 FrameTime: 0.067 ms
[pulsar] light=false:quads=5:texture=false: FPS: 27482 FrameTime: 0.036 ms
[desktop] blur-radius=5:effect=blur:passes=1:separable=true:windows=4: FPS: 8226 FrameTime: 0.122 ms
[desktop] effect=shadow:windows=4: FPS: 10260 FrameTime: 0.097 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 1490 FrameTime: 0.671 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=subdata: FPS: 1613 FrameTime: 0.620 ms
[buffer] columns=200:interleave=true:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 2147 FrameTime: 0.466 ms
[ideas] speed=duration: FPS: 14164 FrameTime: 0.071 ms
[jellyfish] <default>: FPS: 20591 FrameTime: 0.049 ms
Error: Failed to add fragment shader from file None:
Error: 0(26) : warning C7022: unrecognized profile specifier "highp"
Error: 0(26) : error C0502: syntax error at token "highp"
Error:
Error: Failed to add fragment shader from file None:
Error: 0(75) : warning C7022: unrecognized profile specifier "highp"
Error: 0(75) : error C0502: syntax error at token "highp"
Error:
[terrain] <default>:Segmentation fault (core dumped)</pre>
----
}}

=== AMD Tahiti XT [Radeon HD 7970 / R9 280X] + Intel Core i5-11600K @ 3.90GHz ===

'''glmark2 Score: 13781'''

{{collapsible script
| type = details
| title = (click show to expand)
| lang = text
| script = ----
glmark2 2021.02
----
OpenGL Information
GL_VENDOR: AMD
GL_RENDERER: AMD TAHITI (DRM 2.50.0, 5.11.0-44-generic, LLVM 12.0.0)
GL_VERSION: 4.5 (Compatibility Profile) Mesa 21.0.3
----
[build] use-vbo=false: FPS: 12290 FrameTime: 0.081 ms
[build] use-vbo=true: FPS: 19086 FrameTime: 0.052 ms
[texture] texture-filter=nearest: FPS: 18131 FrameTime: 0.055 ms
[texture] texture-filter=linear: FPS: 18165 FrameTime: 0.055 ms
[texture] texture-filter=mipmap: FPS: 18563 FrameTime: 0.054 ms
[shading] shading=gouraud: FPS: 16185 FrameTime: 0.062 ms
[shading] shading=blinn-phong-inf: FPS: 16135 FrameTime: 0.062 ms
[shading] shading=phong: FPS: 16042 FrameTime: 0.062 ms
[shading] shading=cel: FPS: 16036 FrameTime: 0.062 ms
[bump] bump-render=high-poly: FPS: 9338 FrameTime: 0.107 ms
[bump] bump-render=normals: FPS: 19774 FrameTime: 0.051 ms
[bump] bump-render=height: FPS: 19534 FrameTime: 0.051 ms
[effect2d] kernel=0,1,0;1,-4,1;0,1,0;: FPS: 15477 FrameTime: 0.065 ms
[effect2d] kernel=1,1,1,1,1;1,1,1,1,1;1,1,1,1,1;: FPS: 10139 FrameTime: 0.099 ms
[pulsar] light=false:quads=5:texture=false: FPS: 16858 FrameTime: 0.059 ms
[desktop] blur-radius=5:effect=blur:passes=1:separable=true:windows=4: FPS: 5961 FrameTime: 0.168 ms
[desktop] effect=shadow:windows=4: FPS: 9994 FrameTime: 0.100 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 2577 FrameTime: 0.388 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=subdata: FPS: 3585 FrameTime: 0.279 ms
[buffer] columns=200:interleave=true:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 3158 FrameTime: 0.317 ms
[ideas] speed=duration: FPS: 11924 FrameTime: 0.084 ms
[jellyfish] <default>: FPS: 12073 FrameTime: 0.083 ms
[terrain] <default>: FPS: 1350 FrameTime: 0.741 ms
[shadow] <default>: FPS: 9986 FrameTime: 0.100 ms
[refract] <default>: FPS: 2500 FrameTime: 0.400 ms
[conditionals] fragment-steps=0:vertex-steps=0: FPS: 18815 FrameTime: 0.053 ms
[conditionals] fragment-steps=5:vertex-steps=0: FPS: 18705 FrameTime: 0.053 ms
[conditionals] fragment-steps=0:vertex-steps=5: FPS: 18787 FrameTime: 0.053 ms
[function] fragment-complexity=low:fragment-steps=5: FPS: 18759 FrameTime: 0.053 ms
[function] fragment-complexity=medium:fragment-steps=5: FPS: 18691 FrameTime: 0.054 ms
[loop] fragment-loop=false:fragment-steps=5:vertex-steps=5: FPS: 18755 FrameTime: 0.053 ms
[loop] fragment-steps=5:fragment-uniform=false:vertex-steps=5: FPS: 18759 FrameTime: 0.053 ms
[loop] fragment-steps=5:fragment-uniform=true:vertex-steps=5: FPS: 18654 FrameTime: 0.054 ms
}}

=== NVIDIA GTX-1060 6GB + AMD R7 3700X @4.2 GHz, 8 cores, HT off ===

'''glmark2 Score: 20641'''

{{collapsible script
| type = details
| title = (click show to expand)
| lang = text
| script = ----
glmark2 2014.03+git20150611.fa71af2d
----
OpenGL Information
GL_VENDOR: NVIDIA Corporation
GL_RENDERER: GeForce GTX 1060 6GB/PCIe/SSE2
GL_VERSION: 4.6.0 NVIDIA 460.91.03
----
[build] use-vbo=false: FPS: 15192 FrameTime: 0.066 ms
[build] use-vbo=true: FPS: 30325 FrameTime: 0.033 ms
[texture] texture-filter=nearest: FPS: 27634 FrameTime: 0.036 ms
[texture] texture-filter=linear: FPS: 27511 FrameTime: 0.036 ms
[texture] texture-filter=mipmap: FPS: 28397 FrameTime: 0.035 ms
[shading] shading=gouraud: FPS: 26079 FrameTime: 0.038 ms
[shading] shading=blinn-phong-inf: FPS: 25796 FrameTime: 0.039 ms
[shading] shading=phong: FPS: 25060 FrameTime: 0.040 ms
[shading] shading=cel: FPS: 25321 FrameTime: 0.039 ms
[bump] bump-render=high-poly: FPS: 17451 FrameTime: 0.057 ms
[bump] bump-render=normals: FPS: 31963 FrameTime: 0.031 ms
[bump] bump-render=height: FPS: 31608 FrameTime: 0.032 ms
[effect2d] kernel=0,1,0;1,-4,1;0,1,0;: FPS: 20418 FrameTime: 0.049 ms
[effect2d] kernel=1,1,1,1,1;1,1,1,1,1;1,1,1,1,1;: FPS: 12585 FrameTime: 0.079 ms
[pulsar] light=false:quads=5:texture=false: FPS: 28174 FrameTime: 0.035 ms
[desktop] blur-radius=5:effect=blur:passes=1:separable=true:windows=4: FPS: 7331 FrameTime: 0.136 ms
[desktop] effect=shadow:windows=4: FPS: 14034 FrameTime: 0.071 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 2363 FrameTime: 0.423 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=subdata: FPS: 2783 FrameTime: 0.359 ms
[buffer] columns=200:interleave=true:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 2330 FrameTime: 0.429 ms
[ideas] speed=duration: FPS: 19421 FrameTime: 0.051 ms
[jellyfish] <default>: FPS: 17291 FrameTime: 0.058 ms
[terrain] <default>: FPS: 1349 FrameTime: 0.741 ms
[shadow] <default>: FPS: 15688 FrameTime: 0.064 ms
[refract] <default>: FPS: 4783 FrameTime: 0.209 ms
[conditionals] fragment-steps=0:vertex-steps=0: FPS: 28599 FrameTime: 0.035 ms
[conditionals] fragment-steps=5:vertex-steps=0: FPS: 27499 FrameTime: 0.036 ms
[conditionals] fragment-steps=0:vertex-steps=5: FPS: 28191 FrameTime: 0.035 ms
[function] fragment-complexity=low:fragment-steps=5: FPS: 27695 FrameTime: 0.036 ms
[function] fragment-complexity=medium:fragment-steps=5: FPS: 26605 FrameTime: 0.038 ms
[loop] fragment-loop=false:fragment-steps=5:vertex-steps=5: FPS: 27340 FrameTime: 0.037 ms
[loop] fragment-steps=5:fragment-uniform=false:vertex-steps=5: FPS: 27361 FrameTime: 0.037 ms
[loop] fragment-steps=5:fragment-uniform=true:vertex-steps=5: FPS: 26984 FrameTime: 0.037 ms
}}

=== NVIDIA Quadro K1000M 1GB + Intel Core i7-3610Q @2.3 GHz ===
Remark: during glmark2 CPU clock boosted to 3.3 GHz

''' glmark2 Score: 2754 '''

{{collapsible script
| type = details
| title = (click show to expand)
| lang = text
| script = ----
glmark2 2014.03+git20150611.fa71af2d
----
OpenGL Information
GL_VENDOR: NVIDIA Corporation
GL_RENDERER: Quadro K1000M/PCIe/SSE2
GL_VERSION: 4.6.0 NVIDIA 390.138
----
[build] use-vbo=false: FPS: 4154 FrameTime: 0.241 ms
[build] use-vbo=true: FPS: 4205 FrameTime: 0.238 ms
[texture] texture-filter=nearest: FPS: 3791 FrameTime: 0.264 ms
[texture] texture-filter=linear: FPS: 3718 FrameTime: 0.269 ms
[texture] texture-filter=mipmap: FPS: 3761 FrameTime: 0.266 ms
[shading] shading=gouraud: FPS: 3187 FrameTime: 0.314 ms
[shading] shading=blinn-phong-inf: FPS: 3200 FrameTime: 0.312 ms
[shading] shading=phong: FPS: 3078 FrameTime: 0.325 ms
[shading] shading=cel: FPS: 3065 FrameTime: 0.326 ms
[bump] bump-render=high-poly: FPS: 1674 FrameTime: 0.597 ms
[bump] bump-render=normals: FPS: 4329 FrameTime: 0.231 ms
[bump] bump-render=height: FPS: 4174 FrameTime: 0.240 ms
[effect2d] kernel=0,1,0;1,-4,1;0,1,0;: FPS: 2356 FrameTime: 0.424 ms
[effect2d] kernel=1,1,1,1,1;1,1,1,1,1;1,1,1,1,1;: FPS: 1249 FrameTime: 0.801 ms
[pulsar] light=false:quads=5:texture=false: FPS: 3550 FrameTime: 0.282 ms
[desktop] blur-radius=5:effect=blur:passes=1:separable=true:windows=4: FPS: 888 FrameTime: 1.126 ms
[desktop] effect=shadow:windows=4: FPS: 1453 FrameTime: 0.688 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 952 FrameTime: 1.050 ms
[buffer] columns=200:interleave=false:update-dispersion=0.9:update-fraction=0.5:update-method=subdata: FPS: 1277 FrameTime: 0.783 ms
[buffer] columns=200:interleave=true:update-dispersion=0.9:update-fraction=0.5:update-method=map: FPS: 977 FrameTime: 1.024 ms
[ideas] speed=duration: FPS: 2926 FrameTime: 0.342 ms
[jellyfish] <default>: FPS: 1551 FrameTime: 0.645 ms
[terrain] <default>: FPS: 173 FrameTime: 5.780 ms
[shadow] <default>: FPS: 2420 FrameTime: 0.413 ms
[refract] <default>: FPS: 431 FrameTime: 2.320 ms
[conditionals] fragment-steps=0:vertex-steps=0: FPS: 3776 FrameTime: 0.265 ms
[conditionals] fragment-steps=5:vertex-steps=0: FPS: 3061 FrameTime: 0.327 ms
[conditionals] fragment-steps=0:vertex-steps=5: FPS: 3776 FrameTime: 0.265 ms
[function] fragment-complexity=low:fragment-steps=5: FPS: 3775 FrameTime: 0.265 ms
[function] fragment-complexity=medium:fragment-steps=5: FPS: 3058 FrameTime: 0.327 ms
[loop] fragment-loop=false:fragment-steps=5:vertex-steps=5: FPS: 3776 FrameTime: 0.265 ms
[loop] fragment-steps=5:fragment-uniform=false:vertex-steps=5: FPS: 3776 FrameTime: 0.265 ms
[loop] fragment-steps=5:fragment-uniform=true:vertex-steps=5: FPS: 3375 FrameTime: 0.296 ms
}}

OpenGL performance

2022-01-07T16:51:57Z

MariuszXC:

OpenGL performance

2022-01-07T16:51:18Z

MariuszXC: /* NVIDIA RTX2060 6GB + AMD Ryzen 7 3700X 8-Core 4GHz */

OpenGL performance

2022-01-07T16:50:16Z

MariuszXC: GTX-1060 6GB + AMD R7 3700X

OpenGL performance

2022-01-07T16:38:06Z

MariuszXC: AMD Tahiti XT [Radeon HD 7970 / R9 280X] + Intel Core i5-11600K

OpenGL performance

2022-01-06T15:09:33Z

MariuszXC: /* Intel i5-4310M @ 2.70 GHz */

OpenGL performance

2022-01-06T15:08:29Z

MariuszXC: /* NVIDIA RTX2060 6GB + AMD Ryzen 7 3700X 8-Core 4GHz */

OpenGL performance

2022-01-06T15:06:53Z

MariuszXC: /* Intel i5-4310M @ 2.70 GHz */

OpenGL performance

2022-01-06T10:54:47Z

MariuszXC: added another result

Troubleshooting performance issues

2022-01-05T22:12:45Z

MariuszXC: /* Tools for performance evaluation */

{{Troubleshooting}}

'''Troubleshooting performance issues''' will help you if:
* you think that FlightGear could run smoother on your computer
* [[Hardware Recommendations|your hardware]] is not exactly from the latest generation
* you're already fiddling with the settings but can't get any FPS out of it
* you're trying to track down who's responsible for [[Troubleshooting graphics artifacts|graphics artifacts]] you're seeing.
By progressively following all the hints of this page, in fact, you'll slowly get to a [[Howto:Debugging FlightGear Crashes|minimum startup profile]] in which most properly configured machines should have no problems.

== Performance in FlightGear ==
=== What can I aim at? ===
It depends on many things as you'll see. It's easier to tell you what you ''should'' aim at: at least 20 FPS (frames per second). Under this value, things get very choppy and especially flying [[VFR]] will be more difficult. A much more decent value is 30 FPS, also to face better possible stuttering.

It makes no sense to exceed the refresh rate of your monitor. This is typically 60 FPS, but some monitors support speeds as high as 120 FPS.

=== How do I see my framerate? ===
During the simulation, open the ''View > View Options'' menu and toggle ''Show frame rate''. You'll see the number at the bottom right of the screen.

=== How do I use this page? ===
Below, you'll find a list of performance factors. Each of them affect performance, but it's not the same for everyone. So, to find out what you can give up for less stuttering, more regular FPS, or what's killing the framerate, or what could be causing certain artifacts, you'll have to check each of them.

Most important, you'll have to '''check them singularly''', otherwise you'll never be sure if one of the factors is more determinant than others. Also, make your experiments in a fixed environment, like always starting with the same aircraft on the same runway.

The list order is reasoned, so try to follow it, unless you know what you're doing (e.g. everything worked, until you have fiddled with some particular options and broke it.) We know it's boring, but this is the only way to try to fix these issues.

=== Minimal startup profile as a faster alternative ===
If you feel like fiddling with configuration files, command line options and such, you can ease the process and make it more thorough by using the [[Howto:Debugging FlightGear Crashes|minimal startup profile]] that is used for troubleshooting crashes. The idea is always the same: change options one at a time (you can do that also in-sim) and tune them to suit your needs.

== Performance factors ==
=== Hardware setup ===
*'''Problematic video cards''': There is a list of [[Problematic Video Cards]]. Check that yours is not there.
*'''Integrated video cards''': These are probably in the above list, but sometimes you can play with them, reducing "eye candy". Two of these cards are Intel HD graphics 3000 and 4000. With integrated video cards it's also often possible to specify the amount of system memory to be shared and used as video RAM (VRAM).
*'''Video screen''': Actually, this does not affect performance. The problem though is that with a large screen you might want to use higher resolution, but that ''will'' affect performance (and so will color-depth).

=== Operating system and driver setup ===
*'''Background programs''': Check that your operating system is not cluttered by unnecessary programs running in the background. Have as little programs running as possible.
* '''Maximize power performance settings''': If you're running a laptop, chances are your system defaults to a power-saving mode, even with the laptop plugged in. Adjust these settings to maximal power while running FlightGear.
* '''Disable Optimus/Hybrid Graphics''': Most notebooks that run Windows 7 have the so called Optimus Technology (NVidia) or Hybrid Graphics technology (ATI) onboard. This is meant to increase battery life, by automatically switching of the powerful graphics card when it's not needed. However, FlightGear needs it all the time, even if Optimus says it doesn't! This miscommunication results in low framerates (because your computer will run Flightgear on the weak onboard processor) and often FlightGear will quit with the following error:
Unknown exception in the main loop. Aborting...
Possible cause: Not enough space
: If you own an NVidia card, check that it is actually used:
:# Go to the NVidia control panel. Probably located in the Windows Control Panel.
:# Open the 3D Settings tab. Now there's two options you can take:
:#* On the "General settings tab", set "Prefered graphics processor" to NVidia. The NVidia card will now be used for all software. This can decrease battery life significantly.
:#* On the "Programm settings" tab, locate <tt>fgfs.exe</tt> (eg. <tt>C:/Program Files/FlightGear/bin/win32/fgfs.exe</tt>) and assign the NVidia card to it. From now on the NVidia card will be used for FlightGear.
* '''Linux users''': Many newer Linux distributions come with 3D enhanced, composite desktop environments (KDE4, Compiz, Fusion...) They're known to consume CPU and GPU resources, even slowing FlightGear down by 10 FPS. Choosing another window manager from the login screen, like XFCE, results in higher FlightGear performance. Setting "Compositing" to "off" in KDE4 might also help.

=== Graphics drivers setup ===
*'''Graphics card drivers''': Ensure that the manufacturer's graphics card drivers are installed. You may be able to download and install drivers specific to your card from the manufacturer's site. See [[Graphics drivers configuration]].
* '''Graphics drivers settings''': Disable Anti-Aliasing and Anisotropic Filtering or at least set them to their lowest settings. Decreasing the setting for Mip-Mapping to its lowest setting can also help.

=== FlightGear configuration ===
From FlightGear Launcher (some options appear also during the simulation, so better to check them there too):
* '''Rembrandt''': If you enabled the [[Project Rembrandt|Rembrandt renderer]], well, you knew that's experimental. First of all, try to change shadows settings, and consider disabling them. If it's not enough, disable Rembrandt altogether. To check if it's enabled: last tab, ''Advanced > Rendering >'' uncheck ''Rembrandt''.
* '''3D Clouds''': One of the worst offenders in terms of performance impact. Disable them. (in-sim too)
* '''Screen resolution''': The amount of pixels that the graphics card must draw affects performance, so reducing resolution can often help.
* '''Shading''': Set to "flat"
* '''Fog''': set to "nicest" or "disabled"
* '''Visibility''': Try reducing visibility, especially with high-detail scenery. (corresponds to ''bare'' settings in-sim, ''View > LOD settings'')
* '''Log level''': Check that the log level is set to "alert" in ''Advanced > Debugging > Log level''. Logging can cost some FPS.
* '''Everything else''': Both ''Advanced > features'' and ''Advanced > rendering'' have few settings that you can try out.
* '''Texture compression''': If you're experiencing stuttering when turning left/right or when loading new tiles, it is possible that texture compression is not handled correctly. Disable it by adding the property <tt>/sim/rendering/texture-compression=off</tt> in FGrun: ''Advanced > Properties''. This can be tried for nVidia, ATI cards and for Intel integrated chips with MesaGL, that suffer from bugs with texture compression and FlightGear.
*'''Multithreading''': '''''WARNING!''''' If you know what you're doing, in defaults.xml enable <tt><multithreading-mode></tt>. If your framerate is lower with this setting enabled, and both you and your computer survived, disable it again.

During the simulation:
* '''Shaders''': If you cranked all the way up these settings, it's very likely the cause of your FPS problem, and possibly of any [[Troubleshooting graphics artifacts|artifact]]. To check, during the simulation go in ''View > Rendering options'', check the [[Shader]]s slider position. If that seems the problem, you can select ''Custom'' and try to see which one, at which position is the cause of your problems. It can be a particular combination of them, too.
* '''Random features''': Try disabling, one by one, random buildings, random objects, random trees. If any of them seem to be the cause of your problems, you could try to fine-tune their density, or just leave them disabled. They require to reload the scenery.
* '''Everything else''': Try disabling one by one each of the other rendering features. Some will need a restart.
* '''Framerate limiter''': be sure that it's unchecked, or that it's not forcing to a too low FPS.

=== FlightGear simulation choices ===
* '''Time of day''': Changing from nighttime to daytime flying is not only easier on the piloting, but also easier on the graphic requirement. Check the "Time of day" box and select a daytime setting. This is not true, however, if you have shadows enabled: these are pretty consuming, and present only during daytime.
* '''Location''': KSFO is a wonderful airport but also known for a high-volume of traffic, which can slow performance. Try another airport if you encounter performance issues.
* '''Rural flying''': While framerate may initially be as slow as 5 fps during takeoff, they may jump 5x or more after flying out to less-populated areas.
* '''Weather''': Fly in clear skies. Clouds always incur a more or less pronounced performance hit.
* '''Choice of aircraft''': Certain aircraft have lower resource requirements, especially the UFO. The 777 instead is known to be quite heavy.
* '''2D panels''': Although 3D cockpits look very tempting, simple 2D panels are much easier on the framerate.
* '''AI traffic''': [[AI Traffic]] is computer controlled traffic, which includes traffic over the [[Howto: Multiplayer|Multiplayer network]]. By turning off this function you're not able to see other aircraft. Most stuttering, or lag, is caused by the need to load the models for these aircraft while they appear. It can range from a minor annoyance to a crash. Turning off just the computer-generated aircraft (leaving the MP traffic visible), can be done by adding the property <tt>/sim/traffic-manager/enabled=0</tt> to [[FGRun]], through ''Advanced > Properties''.

=== Nothing worked. Now what? ===
It is unlikely, so this must be more than a simple performance issue. You'll need to ask for someone's support and provide them some diagnostic data. See [[Troubleshooting graphics artifacts#Requesting support|Troubleshooting graphics artifacts]] for information on how to do that.

== For the geeks out there ==
=== FPS and frame spacing ===
Frames per second is an average by definition, and as such is not an optimal indicator of performance, because you could have half a second with 100 FPS and the other half with 0 FPS. You'd get a respectable 50 FPS but an unacceptable stutter of 0.5 seconds. A much better one is keeping track of the maximum frame spacing (i.e. the delay/time needed to create new frames), that gives a measure in milliseconds of the worst performance during a fixed interval.

=== Tools for performance evaluation ===
The performance impact can be evaluated by using:
* The frame rate counter (frames created per second)
* The frame spacing indicator (latencies between rendered frames)
* The [[Howto:Use the system monitor|built-in system monitor]] (can be inspected via telnet/http using [[Telnet usage|--telnet=5900]])
* The OSG on-screen stats
* The [[Built-in Profiler]]
* Testing your [[OpenGL performance]]

=== Some more details on the inner workings ===
==== FPS throttling ====
Older versions of FG (before 1.9) would get choppy if the frame rate got too high (well above the monitor refresh rate) but newer versions seem to have less problems with this. However, depending on your system setup you may need to throttle the frame rate to prevent choppiness at high frame rates, but it's not very likely with the current version of FlightGear. Most users anyway don't have enough GPU power to be concerned about frame rates getting too high with current FlightGear versions and those (lucky) users can, to some extent, throttle frame rates by increasing/maximizing eye candy settings.

==== How FPS affects the simulation ====
Keep in mind that things like nasal listeners, animations and other parts of the sim run at the video frame (main loop) rate and if your frame rate gets too low these things might not work as well as they should. As an example, if your aircraft is one armed with machine guns, you may see the guns change rate of fire if your frame rate is too low. This will definitely be the case with the JSBSim P-51D if your frame rates are below 30fps. As more things are decoupled from the main loop this should become less of an issue in future versions of FlightGear.

Additionally, the more the framerate decreases, the more other features of the simulation will suffer. The current [[FlightGear]] software architecture is such that long rendering times (slow framerates) may prevent other parts of the flight simulator, such as the autopilot, from having sufficient CPU time to respond correctly in the context of the simulation.

==== More on factors ====
FlightGear's framerate is influenced by various factors, including:
* [[scenery]] complexity (terrain, clouds, trees, particles, random 3D objects, multiplayer/AI traffic, animated jetways)
* [[cockpit]] complexity (2D vs. 3D)
* environmental options (eg. visibility, precipitation)
* [[FDM]] update interval
* AI scenarios
* [[aircraft]] speed (scenery paging)
* rendering options
* debugging level

=== A note from the developers ===
==== Performance and the OpenGL Shading Language (GLSL) ====
If working through this article doesn't solve the problem, you are probably facing a hardware/driver issue, which means that you may need to fix your drivers (version or settings).

If however at some point the error stops from occurring, that would suggest that FG is using some "code paths" that are not supported by your current driver. We have an increasing number of GLSL shaders, while most of the existing FG code was really only written with a fixed rendering pipeline in mind - and in fact, much of it even predates the OSG port, such as for example the GUI (PLIB/PUI).

In summary, our way of using OSG is not particularly optimized, and we're doing a lot of things that are known to be inefficient, such as having lots of GL state changes, and using legacy GL code in conjunction with more modern code. All of these also affecting compatibility, because GLSL, unlike DirectX shader code, is not bytecode, but compiled on-the-fly by your driver - in other words, each GPU vendor will typically have their own GLSL compiler implementation, and these are known to be fragile under certain circumstances. We do not have the resources to test each shader on all major hardware platforms, so we really rely on end-user quality feedback, e.g. by using tools like gDebugger or the corresponding ATI/AMD and nvidia equivalents.

==== The move to OpenSceneGraph (OSG) ====
Some people have been suggesting to our core/shaders developers to switch to AMD/ATI or even Intel hardware in order to get rid of certain problems. But it's not as simple as that to be honest: FlightGear is a fairly old code base, and it also isn't particularly modern - these days, many parts are basically unmaintained, and haven't been touched in years, despite containing lots of legacy code.

OSG is much more powerful than you may think, but it cannot magically fix all the problems that FlightGear introduces, we have a ton of features that basically still date back to the pre-OSG days, i.e. when we were using purely PLIB and SDL. OSG itself is generally rock-solid and there are rarely any issues found with it. To see for yourself, just run fgviewer or any of the OSG examples (osgviewer).

As recently pointed out elsewhere, those OSG examples even support Intel GMA cards, often even shaders to some degree - but we have never really formalized the way OpenGL/OSG code is written/developed for FlightGear, including effects and shaders.

[[Category:Troubleshooting]]

[[es:Resolviendo_problemas_de_rendimiento]]

OpenGL performance

2022-01-05T22:12:28Z

MariuszXC: OpenGL performance for i5-4310M

Howto:Work with AC3D files in Blender

2021-12-10T10:17:30Z

MariuszXC: /* Importing */

Many [[FlightGear]] [[aircraft]] modellers prefer [[Blender]] as their 3D-modelling editor. Blender is a powerful, robust and open-source 3D modelling suite. FlightGear primarily uses the [[AC3D_file_format|AC3D file format]] (<code>.ac</code>) to model aircraft, [[scenery]] models, and many other things. With the AC3D file format first released in 1996<ref>http://fileformats.archiveteam.org/wiki/AC3D_Model</ref>, modern versions of Blender do not bother maintaining support for the format. However, add-ons exist to extend Blender's functionality in order to allow the import and export of these files.

{{TOC limit|3}}

== Importing and exporting AC3D files ==
{{note| Modern versions of Blender (2.5+) require an add-on to work with AC3D (<code>.ac</code>) files.}}
=== Addons ===

The prominent add-on for using AC3D files in Blender is called ''Blender-AC3D''. It has been forked from its original to provide support for Blender 2.8.

{| class="wikitable"
|-
! Blender version !! Addon !! Remarks
|-
| 2.80 - 2.90 || {{github source|user=NikolaiVChr|repo=Blender-AC3D|branch=2.80|text=NikolaiVChr/Blender-AC3D (GitHub)}}. || NikolaiVChr's fork of majic79's add-on, with a special branch for Blender 2.80
|-
| 2.63 - 2.7a || {{github source|user=NikolaiVChr|repo=Blender-AC3D|branch=master|text=NikolaiVChr/Blender-AC3D (GitHub)}} || NikolaiVChr's fork of majic79's add-on. For more information read {{forum link|t=13442|title=Blender 2.6 AC3D Importer & Exporter}}
|-
| 2.62 || {{github source|proj=majic79|repo=Blender-AC3D|branch=BL2.62|text=majic79/Blender-AC3D (GitHub)}} || Branch of majic79's plugin targeting Blender 2.62 (Abandoned)
|-
| 2.60 || {{github source|proj=majic79|repo=Blender-AC3D|branch=BL2.60|text=majic79/Blender-AC3D (GitHub)}} || Branch of majic79's plugin targeting Blender 2.60 (Abandoned)
|-
| 2.59 || {{github source|proj=majic79|repo=Blender-AC3D|branch=BL2.59|text=majic79/Blender-AC3D (GitHub)}} || Branch of majic79's plugin targeting Blender 2.59 (Abandoned)
|-
| <2.5 || N/A || Versions of Blender below 2.5 include out of the box support for the AC3D file format, simply enable the add-on in <code>Preferences > Addons</code>
|}

==== Notes ====
* Before you export a model with this addon, make sure that you set the UV map and texture inside the material, not just inside the UV editor. See the video tutorial [https://www.youtube.com/watch?v=URMjoFSm5pk here].
* Before you export make sure to exit ''Edit Mode'' or some of your last changes won't be exported.
* Inside Blender when you want to see the textures, be sure to set the shader to GLSL (or for 2.7+ just set view mode to materials). Alternatively set textured solid in solid view.
* To see textured surfaces as they will be shown in FlightGear, go into the material texture and set the blend type to ''Multiply'' instead of the default ''Mix'' (the importer will also do this automatically). An example plane that will look very different if this is not done is the FGAddon aircraft {{fgaddon source|path=Aircraft/ASK13|commit=1363|text=ASK-13}}, notice the wingtips.
* The final model might display color mismatches (Texture color vs Material color) when viewed in Flightgear. Hand editing the [[AC files: Basic changes to textures and colors#Materials|materials]] section of the exported AC3D file might fix this.
* If you wonder where to put the scripts you could open blender's user preferences ({{Key press|Ctrl|Alt|U}}, or ''File > User Preferences'') tick for example Import/Export and extent the information concerning an existing script. Usually this throws the path. For for example Ubuntu 14.04LTS/Blender 2.79b it is: <code>/usr/share/blender/scripts/addons/</code>. In recent Ubuntu versions blender is distributed as a snap image. In such cases blender addon scripts are placed in: <code>$HOME/.config/blender/X.YY/scripts/addons/</code> (where X.YY is blender version, for example 2.82).
* Be aware that Blender only has greyscale for emission and ambient colors. If you want to export/import a color for those, import/export options gives you capability to choose to use Blenders mirror color for that.
* The importer will not fail if it does not locate a texture, instead it will issue warnings. Pull down the top bar to see if there was any, they will be orange lines.
* The exporter will not fail if it tries to save a texture without data, instead it will issue warnings. Pull down the top bar to see if there was any, they will be orange lines. Notice that since AC3D only support 1 texture per object, if multiple textures are attached to an object in Blender the last of the textures that has any data, if any, will be the one that get exported, but it will still warn about the missing data in the others, so take care.
* Orientation: The default settings in the plugin correspond to the FlightGear coordinate system (-X forward and Z up, also see: [[Howto:3D_Aircraft_Models]]). The default settings are: Forward -Z and Up Y.

You can report bugs with the addon [https://github.com/NikolaiVChr/Blender-AC3D/issues here], but please include problematic <code>.ac</code>/<code>.blend</code> files and their textures.

=== Importing ===

{{main article|Working with FlightGear models in Blender}}
{{note|If you do not see the option for <code>AC3D (.ac)</code> under <code>File > Import</code>, your add-on is either not installed, not enabled, or not working correctly.}}
Once the add-on is installed, AC3D models can be imported in the same manner as any other model foramat into Blender by using the <code> File > Import > AC3D (.ac)</code> dialog.
[[File:Blender AC3D import dialog.png|thumb|This figure demonstrates how to import an AC3D model in Blender using a third-party addon.]]

{{Appendix}}
{{3d}}
[[Category:Modeling]]

Howto:Work with AC3D files in Blender

2021-12-10T10:14:06Z

MariuszXC: /* Notes */ - added scripts location in cases when blender is distributed as a snap image.

Many [[FlightGear]] [[aircraft]] modellers prefer [[Blender]] as their 3D-modelling editor. Blender is a powerful, robust and open-source 3D modelling suite. FlightGear primarily uses the [[AC3D_file_format|AC3D file format]] (<code>.ac</code>) to model aircraft, [[scenery]] models, and many other things. With the AC3D file format first released in 1996<ref>http://fileformats.archiveteam.org/wiki/AC3D_Model</ref>, modern versions of Blender do not bother maintaining support for the format. However, add-ons exist to extend Blender's functionality in order to allow the import and export of these files.

{{TOC limit|3}}

== Importing and exporting AC3D files ==
{{note| Modern versions of Blender (2.5+) require an add-on to work with AC3D (<code>.ac</code>) files.}}
=== Addons ===

The prominent add-on for using AC3D files in Blender is called ''Blender-AC3D''. It has been forked from its original to provide support for Blender 2.8.

{| class="wikitable"
|-
! Blender version !! Addon !! Remarks
|-
| 2.80 - 2.90 || {{github source|user=NikolaiVChr|repo=Blender-AC3D|branch=2.80|text=NikolaiVChr/Blender-AC3D (GitHub)}}. || NikolaiVChr's fork of majic79's add-on, with a special branch for Blender 2.80
|-
| 2.63 - 2.7a || {{github source|user=NikolaiVChr|repo=Blender-AC3D|branch=master|text=NikolaiVChr/Blender-AC3D (GitHub)}} || NikolaiVChr's fork of majic79's add-on. For more information read {{forum link|t=13442|title=Blender 2.6 AC3D Importer & Exporter}}
|-
| 2.62 || {{github source|proj=majic79|repo=Blender-AC3D|branch=BL2.62|text=majic79/Blender-AC3D (GitHub)}} || Branch of majic79's plugin targeting Blender 2.62 (Abandoned)
|-
| 2.60 || {{github source|proj=majic79|repo=Blender-AC3D|branch=BL2.60|text=majic79/Blender-AC3D (GitHub)}} || Branch of majic79's plugin targeting Blender 2.60 (Abandoned)
|-
| 2.59 || {{github source|proj=majic79|repo=Blender-AC3D|branch=BL2.59|text=majic79/Blender-AC3D (GitHub)}} || Branch of majic79's plugin targeting Blender 2.59 (Abandoned)
|-
| <2.5 || N/A || Versions of Blender below 2.5 include out of the box support for the AC3D file format, simply enable the add-on in <code>Preferences > Addons</code>
|}

==== Notes ====
* Before you export a model with this addon, make sure that you set the UV map and texture inside the material, not just inside the UV editor. See the video tutorial [https://www.youtube.com/watch?v=URMjoFSm5pk here].
* Before you export make sure to exit ''Edit Mode'' or some of your last changes won't be exported.
* Inside Blender when you want to see the textures, be sure to set the shader to GLSL (or for 2.7+ just set view mode to materials). Alternatively set textured solid in solid view.
* To see textured surfaces as they will be shown in FlightGear, go into the material texture and set the blend type to ''Multiply'' instead of the default ''Mix'' (the importer will also do this automatically). An example plane that will look very different if this is not done is the FGAddon aircraft {{fgaddon source|path=Aircraft/ASK13|commit=1363|text=ASK-13}}, notice the wingtips.
* The final model might display color mismatches (Texture color vs Material color) when viewed in Flightgear. Hand editing the [[AC files: Basic changes to textures and colors#Materials|materials]] section of the exported AC3D file might fix this.
* If you wonder where to put the scripts you could open blender's user preferences ({{Key press|Ctrl|Alt|U}}, or ''File > User Preferences'') tick for example Import/Export and extent the information concerning an existing script. Usually this throws the path. For for example Ubuntu 14.04LTS/Blender 2.79b it is: <code>/usr/share/blender/scripts/addons/</code>. In recent Ubuntu versions blender is distributed as a snap image. In such cases blender addon scripts are placed in: <code>$HOME/.config/blender/X.YY/scripts/addons/</code> (where X.YY is blender version, for example 2.82).
* Be aware that Blender only has greyscale for emission and ambient colors. If you want to export/import a color for those, import/export options gives you capability to choose to use Blenders mirror color for that.
* The importer will not fail if it does not locate a texture, instead it will issue warnings. Pull down the top bar to see if there was any, they will be orange lines.
* The exporter will not fail if it tries to save a texture without data, instead it will issue warnings. Pull down the top bar to see if there was any, they will be orange lines. Notice that since AC3D only support 1 texture per object, if multiple textures are attached to an object in Blender the last of the textures that has any data, if any, will be the one that get exported, but it will still warn about the missing data in the others, so take care.
* Orientation: The default settings in the plugin correspond to the FlightGear coordinate system (-X forward and Z up, also see: [[Howto:3D_Aircraft_Models]]). The default settings are: Forward -Z and Up Y.

You can report bugs with the addon [https://github.com/NikolaiVChr/Blender-AC3D/issues here], but please include problematic <code>.ac</code>/<code>.blend</code> files and their textures.

=== Importing ===

{{main article|Working with FlightGear models in Blender}}
{{note|If you do not see the option for <code>AC3D (.ac)</code> under <code>File > Import</code>, your add-on is either not installed, or not working correctly.}}
Once the add-on is installed, AC3D models can be imported in the same manner as any other model foramat into Blender by using the <code> File > Import > AC3D (.ac)</code> dialog.
[[File:Blender AC3D import dialog.png|thumb|This figure demonstrates how to import an AC3D model in Blender using a third-party addon.]]

{{Appendix}}
{{3d}}
[[Category:Modeling]]

Hackathon Proposal: Multiplayer Improvements

2021-11-27T20:39:03Z

MariuszXC: /* Progress during the Hackaton */

Hackathon Proposal: Multiplayer Improvements

2021-11-10T09:00:32Z

MariuszXC: Hackaton progress description

{{Hackathon Proposal 2021
| title = Multiplayer Improvements
| sponsor = MariuszXC
| supporters = MariuszXC
| summary = Improving ground-referenced presentation of remote players' planes
| background = forum topic https://forum.flightgear.org/viewtopic.php?f=4&t=39846
| details = Due to scenery differences some aircraft are shown partially sunk or floating, even when their GND flag is true.
| skills = Nasal
}}

=== Progress during the Hackaton ===

Under the topic of Multiplayer Improvements we actually worked on two issues:
* ground reference of remote aircraft,
* tracing a cause of low resolution remote aircraft model displayed together with the cockpit model.

With the first issue we had success applying the necessary corrections, so a model does not appear floating or partially sunk.
Since the offset needed to be appliet to a low-res model and to the high-res may be different, we are investigating further on how to dynamically decide which needs to be applied.

With the second issue we identified the cause of the problem, defined a solution and are working on implementing it.

Hackathon Proposal: Multiplayer Improvements

2021-10-30T09:52:24Z

MariuszXC: Created page with "{{Hackathon Proposal 2021 | title = Multiplayer Improvements | sponsor = MariuszXC | supporters = MariuszXC | summary = Improving ground-referenced..."