How does OpenGL work at the lowest level? [closed]

by

This question is almost impossible to answer because OpenGL by itself is just a front end API, and as long as an implementations adheres to the specification and the outcome conforms to this it can be done any way you like.

The question may have been: How does an OpenGL driver work on the lowest level. Now this is again impossible to answer in general, as a driver is closely tied to some piece of hardware, which may again do things however the developer designed it.

So the question should have been: “How does it look on average behind the scenes of OpenGL and the graphics system?”. Let’s look at this from the bottom up:

  1. At the lowest level there’s some graphics device. Nowadays these are GPUs which provide a set of registers controlling their operation (which registers exactly is device dependent) have some program memory for shaders, bulk memory for input data (vertices, textures, etc.) and an I/O channel to the rest of the system over which it recieves/sends data and command streams.

  2. The graphics driver keeps track of the GPUs state and all the resources application programs that make use of the GPU. Also it is responsible for conversion or any other processing the data sent by applications (convert textures into the pixelformat supported by the GPU, compile shaders in the machine code of the GPU). Furthermore it provides some abstract, driver dependent interface to application programs.

  3. Then there’s the driver dependent OpenGL client library/driver. On Windows this gets
    loaded by proxy through opengl32.dll, on Unix systems this resides in two places:

    • X11 GLX module and driver dependent GLX driver
    • and /usr/lib/libGL.so may contain some driver dependent stuff for direct rendering

    On MacOS X this happens to be the “OpenGL Framework”.

    It is this part that translates OpenGL calls how you do it into calls to the driver specific functions in the part of the driver described in (2).

  4. Finally the actual OpenGL API library, opengl32.dll in Windows, and on Unix /usr/lib/libGL.so; this mostly just passes down the commands to the OpenGL implementation proper.

How the actual communication happens can not be generalized:

In Unix the 3<->4 connection may happen either over Sockets (yes, it may, and does go over network if you want to) or through Shared Memory. In Windows the interface library and the driver client are both loaded into the process address space, so that’s no so much communication but simple function calls and variable/pointer passing. In MacOS X this is similar to Windows, only that there’s no separation between OpenGL interface and driver client (that’s the reason why MacOS X is so slow to keep up with new OpenGL versions, it always requires a full operating system upgrade to deliver the new framework).

Communication betwen 3<->2 may go through ioctl, read/write, or through mapping some memory into process address space and configuring the MMU to trigger some driver code whenever changes to that memory are done. This is quite similar on any operating system since you always have to cross the kernel/userland boundary: Ultimately you go through some syscall.

Communication between system and GPU happen through the periphial bus and the access methods it defines, so PCI, AGP, PCI-E, etc, which work through Port-I/O, Memory Mapped I/O, DMA, IRQs.

More Related Contents:

  1. Why does OpenGL not support multiple index buffering?
  2. How do I compose a rotation matrix with human readable angles from scratch?
  3. Rendering meshes with multiple indices
  4. Should I ever use a `vec3` inside of a uniform buffer or shader storage buffer object?
  5. About OpenGL texture coordinates
  6. how should i handle (morphing) 4D objects in opengl? [closed]
  7. Why transform normals with the transpose of the inverse of the modelview matrix?
  8. How to use GLUT/OpenGL to render to a file?
  9. glVertexAttribPointer and glVertexAttribFormat: What’s the difference?
  10. Rotating a Group of Vectors
  11. GLSL fixed function fragment program replacement
  12. What does “immediate mode” mean in OpenGL?
  13. Matrix inverse accuracy
  14. Is OpenGL coordinate system left-handed or right-handed?
  15. The purpose of Model View Projection Matrix
  16. depth buffer got by glReadPixels is always 1
  17. Using GLEW to use OpenGL extensions under Windows
  18. Using the mouse scrollwheel in GLUT
  19. Opengl pixel perfect 2D drawing
  20. How do I find my mouse point in a scene using SceneKit?
  21. What are Vertex Array Objects?
  22. Initializing OpenGL without GLUT
  23. Multiple textures in GLSL – only one works
  24. Is it possible to rotate an object around its own axis and not around the base coordinate’s axis?
  25. GLSL, semaphores?
  26. How to cast int to const GLvoid*?
  27. Frequency of shader invocations in rendering commands
  28. glVertexAttribPointer clarification
  29. What are shaders in OpenGL and what do we need them for? [closed]
  30. Convert Quaternion rotation to rotation matrix?

Leave a Comment