drawing a pixelarray fast and efficient on linux

Question

How can I draw a pixel array very fast in c++?

I've seen many questions like this on stackoverflow,
they are all answered with:

• use gdi (windows)
• use opengl
• ...

but there must be a way, how opengl is doing it!

---

I'm writing a little raytracer and need to draw every pixel
many times per second.
opengl is able to do it, platform independent and fast,
so how can i achieve that without opengl?

And "without opengl" dos not mean

• use sdl (slow)
• use this / that library

Please only suggest the platform native methods
or the library closest to that.

If it is possible (i know it is)
how can I do this?
platform independent solutions are preferred.

Answer 1

Drawing graphics on Linux you either have to use X11, or OpenGL. (And in the near future Wayland may be another option). In Linux there is no "native" way of doing graphics, because the Linux kernel doesn't care about graphics APIs. It provides a interfaces (DRM) using which graphics systems are then implemented in user space. If you just want to splat pixels on the screen, without caring about windows then you could also mmap /dev/fbdev – but you normally don't want that, because nobody wants his screen being clobbered by some program he can't move or hide.

Drawing single points is inefficient, no matter which API being uses, due to the protocol overhead.

So X11 it is. So the best bet is to use the MIT-SHM extension which you use to alter pixels in a buffer, which is then blitted in whole by the X11 server. Of course doing this using the pure X11 Xlib functions is annoyingly cumbersome. So this is what SDL effectively nicely wraps up for you.

The other option is OpenGL. OpenGL is not a library! It's a system level API, that gives you almost direct access to the GPU. And it integrates nicely with X11. Yes, the API is provided through a library that's being loaded, but technically that library is just a "wrapper" or "interface" to the actual driver. Drawing single points with OpenGL makes no sense. But you can "batch up" several points into a list (using a vertex array) and then process that list. So the idea is to collect all the incoming points between two display refresh intervals and draw them in one single batch.

platform independent solutions are preferred.

Why are you asking about native APIs then? By definition there can be no plattform independent native API. Either you're native, or you're plattform independent.

And in your particular scenario I think SDL would be the best solution, because it offers just the right kind of abstraction and program side interface for a raytracer. Just FYI: Virtual Machines like QEmu use SDL.

Or you use OpenGL which is a real plattform neutral API widely supported.

Answer 2

Drawing graphics on Linux you either have to use X11, or OpenGL.

This is absolutely false! Counterexample: there's platforms that don't run X11, yet they display pixels (eg. fonts).

Sidenote. OpenGL usually depends on X11 (it's possible, albeit hard, to run OpenGL without X11).

As @datenwork says, there's at least 2 other ways to draw pixels:

1. The framebuffer device (fbdev), an abstraction to interface with graphics hardware. Very old, designed by Martin Schaller, see the kernel docs. Source code is here. Also see here. Here's the simplest possible framebuffer driver.
2. The Direct Rendering Manager (DRM), a kernel subsystem that provides an API for userland apps to send commands/data directly to the GPU. (Seems suspiciously similar to what OpenGL does, but idk!). Source code is here. Here's a DRM example that inititializes a simple display pipeline.

Both of these are part of the kernel, so they're lower-level than X11, which is not part of the kernel. Both can draw arbitrary pixels (eg. penguins). I'd guess both of these are platform-independent (like OpenGL).

See this for more on how to draw stuff on Linux.