What exactly are the differences in rendering between OpenGL and Software?

[frozenLake]

To give a little more context, I notice that a lot of people say that OpenGL is terrible and software looks better, and while I play mostly on the OpenGL side of things (mainly because I am MD2 using trash), I do notice a few unfortunate differences between the two renders, such as lighting effects being prone to be far darker, as well as the z-fighting when it comes to mods that add cape-chase items.

But this has made me curious, so I ask the community: what exactly are the rendering differences? It might be beneficial to have a list of this sort in the case of another coder making an attempt to have parity, so this thread might be able to serve a purpose other than sating my curiosity.

 

[Zwip-Zwap Zapony]

I'm pretty sure software rendering is done entirely on the CPU, while OpenGL rendering is done on the GPU (thus increasing performance for toasters bad and old computers with "good" GPUs and such).
Besides that, software can render colourmaps correctly (changing the hue and saturation of stuff), can render ripples on top of water (and other) FOFs (if the FOF is set up to have ripples), can have specialized palette changes (OpenGL is hard-coded to just tint the screen, I think), and can render "portal" lines, but is limited to just 256 colours, thus dark halls and such may "flicker" and/or get a gray or otherwise weird colour and such. Also the ground textures may flicker around horizontally, as if the ground is shaking a little, when moving around in complex-shaped sectors.

OpenGL renders colormaps by just tinting the insides (so a red object in a blue colourmap will appear black in OpenGL, while blue in software's hue-changing-ness).
Sadly, OpenGL can not render ripples on the surface of FOFs (but the screen will still wave softly when the camera is submerged in water), but it's not really a major thing, so that's okay.
As said above in the software section, palette changes, such as when using the Armaggeddon Shield's blast, being teleported, etcetera, have different "sub"-palettes which can be customized by custom palettes, while OpenGL just tints the screen with probably-hard-coded colours (which as a result also affects MD2s and such).
Speaking of MD2s, yeah, they're OpenGL-exclusive. Personally I prefer the sprited look, however, but I understand that other people may prefer MD2s.
As for portal lines, they're not used anywhere(?) in vanilla SRB2, and their use for/in custom maps is limited, so the lack of support for them is not too bad.
Also, OpenGL is limited to 16777216 (256x256x256) colours instead of 256, thus making dark halls, translucent objects, etcetera appear much smoother. Whether that's a good or bad thing is subjective. I personally prefer OpenGL for just that reason.
And the flickering ground textures when moving? If it's not completely gone, it's definitely far less noticable than in software.
Additionally, OpenGL supports the "shadow" console variable, which software doesn't support.
Edit: Oh, and you can use texture filtering in OpenGL to smooth out textures or add mip-maps to make far textures look less grainy, but this will leave ugly edges around translucent objects (such as basically all sprited objects), so I don't really recommend using that.
Edit 2: Also, another huge thing is that looking up/down in software is much different from OpenGL.

One last thing... When playing in software mode in non-green resolutions (multiples of 320x200), software will render in the aspect ratio the resolution would have, while OpenGL renders everything (the world, the HUD, everything) in locked 8:5 aspect ratio (just like the green resolutions), and just "stretches" it out over the chosen resolution. But generally, this shouldn't matter a lot at all for you (unless you custom-compile a version of the game to have ultra-wide (or ultra-tall) resolutions). At least I'm pretty sure that is the case, judging by a few extreme tests with 1920x1080 resolution (16:9 (or 8:4.5) aspect ratio).

If there are any points about this which I'm wrong on or missed, please correct me.



Edit: So TL;DR: Stick with OpenGL for quality, or software for stylism.

 

[MK.exe]

Slopes render better on OpenGL(?)

 

[toaster]

geez guys stop making fun of the fact i don't have a good GPU

ZZZ is mostly right, except where they use the word "quality" to describe OGL. I'm pretty sure the term is "blander than crackers"*. Slopes actually render worse in OGL, by the way! Or, well, more specifically their midtextures have a couple bugs in OGL that aren't present in software. This is because of 2.1.15 coming too quickly for those working on slopes' OGL implementations, and this issue will be gone by 2.2. Probably.

*a joke because #notallimplementations

 

[MascaraSnake]

It might be beneficial to have a list of this sort in the case of another coder making an attempt to have parity

Like this one?

 

[Zwip-Zwap Zapony]

[Zappy] is mostly right, except where they use the word "quality" to describe OGL. I'm pretty sure the term is "blander than crackers".

By "quality", I mean the ground textures don't flicker about horizontally when moving, and the game isn't limited to 256 colours (which I'm aware is not just a limitation, also a stylistic "choice"). I am aware many other things which work in software don't work in OpenGL, and as I said, "stick with - software for stylism".
To hugely over-exaggerate it as an example, take Team Fortress 2 and Half-Life 2. Half-Life 2 would be OpenGL, and Team Fortress 2 would be software. OpenGL has more "quality", while software is definitely much more stylized. Which of those two art styles one would prefer is subjective.

 

[Fres]

OpenGL also renders the terrain with perspective correction, which allows you to be able to look up or down without the view getting screwed up. This is especially useful in first person mode, but the sprites appear flat at steep angles because of it.

 

[Monster Iestyn]

While software may be "limited" to 32 different levels of sector brightness, 10 levels of transluencies and in general a palette of 256 colors, you CAN pull off some cool palette tricks with these things. For instance, I've known Nev3r to do stuff like change one level of sector brightness into a totally different thing like a water palette via a custom COLORMAP lump. The colormap linedef special is also capable of applying your custom colormap only to specific levels of the 32 software sector brightnesses too (it's controlled by the middle texture btw). And before 2.0, our translucency maps were totally different (they were probably from Doom or Doom Legacy or Boom or whatever) - at least one or two of them could actually make only specific colors turn translucent, and others stay opaque. This all thanks to them being controlled by lumps in srb2.srb.

Of course it's easier to think software is "limiting", and that more regular sector brightnesses and translucencies are objectively better. Fair enough, can't argue with that.


And of course yes, this is just how SRB2 has the renderers implemented currently. OpenGL may be totally capable of pulling off all of software's tricks with shaders for all I know.

 

[sluggard]

Colormaps look more colorful in Software mode than OpenGL .

 

[wolfs]

To hugely over-exaggerate it as an example, take Team Fortress 2 and Half-Life 2. Half-Life 2 would be OpenGL, and Team Fortress 2 would be software. OpenGL has more "quality", while software is definitely much more stylized. Which of those two art styles one would prefer is subjective.

This is a terrible analogy because, for one, TF2's source engine has far less limitations than HL2's. The games also both use DirectX by default, and only use OpenGL when explicitly set or when playing on an OS other than Windows.

 

[Final Radiance]

This is a terrible analogy because, for one, TF2's source engine has far less limitations than HL2's. The games also both use DirectX by default, and only use OpenGL when explicitly set or when playing on an OS other than Windows.

He's talking about their actual visual styles, not what they're rendered on.

TF2 has cartoonish characters while HL2 goes for a realistic approach

 

[Mystic]

There are a bunch of minor differences, but I think it's really the major ones that bear repeating because people often seem to get tied up heavily in personal opinions about which is better than the other:

• Software uses a rigid 256-color palette. OpenGL does not. This leads to a few significant differences in how the game handles colors:
  • Software's palette enables the concept of colormaps, which we use heavily in our game, especially for liquids. OpenGL cannot use colormaps at all due to lacking a palette, and therefore fakes it ineffectively.
  • Both renderers handle light level entirely differently. Software essentially creates black fog that prevents you from seeing farther away, while OpenGL just darkens everything in the area without any lack of distance vision. This leads to a far more dramatic darkness in software, but at the cost of significant dithering.
• Software renders the game as a two point perspective drawing. OpenGL renders using polygons. This is most noticeable when looking far up and down, as two point perspective drawings break down when you place the vanishing points too far vertically from the center of the drawing.
• Software uses a single core of your CPU to render the game. OpenGL uses your GPU. Depending on which of these is more powerful, you will get different performance from each. For most modern machines, OpenGL will run faster.
• They are both riddled with awful bugs everywhere.

 

[Zwip-Zwap Zapony]

This is a terrible analogy because, for one, TF2's source engine has far less limitations than HL2's. The games also both use DirectX by default, and only use OpenGL when explicitly set or when playing on an OS other than Windows.

I was talking about their art styles. Team Fortress 2 is much more stylized than Half-Life 2, while Half-Life 2 looks more realistic, which I will refer to as having higher "quality", and software in SRB2 is much more "stylized" than OpenGL, while OpenGL has more quality (though not in the same way as HL2).

In other words: Software is pretty "stylized", whether it be fully intentional or not, and OpenGL isn't limited to 256 colours. Thus software has stylism, and OpenGL has "quality". Whether one prefers 256-coloured stylism over unlimited-coloured lack of stylism is subjective.